@buildbase/sdk 0.0.27 → 0.0.29

package/dist/react/index.d.ts

@@ -0,0 +1,3180 @@
+import { z } from 'zod';
+import * as react from 'react';
+import react__default, { ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+interface IDocument {
+    _id: string;
+    /** Optional; some APIs only return _id. Prefer _id for identity. */
+    id?: string;
+    createdAt: string;
+    updatedAt: string;
+    deleted: boolean;
+}
+interface IUser extends IDocument {
+    _id: string;
+    name: string;
+    email: string;
+    /** Profile image URL. Often omitted or empty from API. */
+    image?: string;
+    role: 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>;
+}
+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;
+    subscriptionStatus: 'active' | 'trialing' | 'canceled' | 'past_due' | 'paused' | 'incomplete' | 'unpaid';
+    stripePriceId?: string;
+    stripeCurrentPeriodEnd?: string;
+    cancelAtPeriodEnd: boolean;
+    billingInterval?: BillingInterval;
+    /** Trial start date (ISO string). Set when subscription is in trial. */
+    trialStart?: string;
+    /** Trial end date (ISO string). Set when subscription is in trial. */
+    trialEnd?: string;
+    /** When the subscription was canceled (ISO string). Soft-delete marker. */
+    canceledAt?: string;
+    /** Dunning state: 'none', 'notified', 'warning', 'final', 'suspended'. */
+    dunningState?: string;
+    /** Whether this subscription uses per-seat pricing. */
+    seatPricingEnabled?: boolean;
+    /** Current billable seat count. */
+    currentSeatCount?: number;
+    createdAt: string;
+    updatedAt: string;
+    plan?: {
+        _id: string;
+        name: string;
+        slug: string;
+        description?: string;
+        /** Stripe currency code (e.g. 'usd', 'inr', 'eur'). */
+        currency?: string;
+    };
+}
+interface ISubscriptionItem {
+    _id: string;
+    type: 'feature' | 'limit' | 'quota';
+    name: string;
+    slug: string;
+    description?: string;
+    category: string;
+}
+/** Per-interval quota value (plan-group/versions and public plans schema). */
+interface IQuotaIntervalValue {
+    included: number;
+    /** 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) */
+interface IQuotaByInterval {
+    monthly?: IQuotaIntervalValue;
+    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;
+    /** Per-seat pricing config. When enabled, a second recurring item is on the subscription. */
+    seatPricing?: {
+        enabled: boolean;
+        includedSeats: number;
+        /** Maximum seats allowed. 0 or undefined = unlimited. */
+        maxSeats?: number;
+        perSeat: IBasePricing;
+    };
+    /** Stripe Price IDs for the per-seat recurring price. */
+    seatStripePrices?: 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;
+    name: string;
+    status: 'draft' | 'published';
+    features?: Record<string, boolean>;
+    limits?: Record<string, number>;
+    /** 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;
+    archived?: boolean;
+    deleted?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    id?: string;
+    stripeProductId?: string;
+}
+/** Plan version summary (e.g. plan.latestVersion from subscription API) with subscriptionItems as IDs. */
+interface IPlanVersionSummary extends Omit<IPlanVersion, 'subscriptionItems'> {
+    subscriptionItems?: string[];
+}
+interface IPlan {
+    _id: string;
+    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;
+    createdAt?: string;
+    updatedAt?: string;
+    id?: string;
+}
+interface IPlanGroupLatestVersion {
+    _id: string;
+    version: number;
+    planVersionIds: string[];
+    requiredItems: string[];
+    status: 'draft' | 'published';
+    isCurrent?: boolean;
+    isLegacy?: boolean;
+    archived?: boolean;
+    deleted?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    description?: string;
+}
+interface IPlanGroup {
+    _id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    latestVersion?: IPlanGroupLatestVersion;
+    archived?: boolean;
+    deleted?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    id?: string;
+}
+interface IPlanGroupVersion {
+    _id: string;
+    version: number;
+    description?: string;
+    group?: {
+        _id: string;
+        name: string;
+        description?: string;
+    };
+    planVersionIds: IPlanVersionWithPlan[] | string[];
+    requiredItems?: string[];
+    status?: 'draft' | 'published';
+    isCurrent?: boolean;
+    isLegacy?: boolean;
+    archived?: boolean;
+    deleted?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    id?: string;
+}
+interface ISubscriptionResponse {
+    subscription: ISubscription | null;
+    planVersion: IPlanVersion | null;
+    plan: IPlan | null;
+    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?: {
+        newPlans: IPlanVersionWithPlan[];
+        updatedPlans: IPlanVersionWithPlan[];
+        removedPlans: IPlanVersionWithPlan[];
+    };
+}
+interface IPlanGroupInfo {
+    _id: string;
+    name: string;
+    slug: string;
+    description?: string;
+}
+/** Response from GET workspaces/:id/subscription/plan-group (and by version). */
+interface IPlanGroupResponse {
+    /** 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, 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;
+    currency?: string;
+    successUrl?: string;
+    cancelUrl?: string;
+}
+interface ICheckoutSessionResponse {
+    /** Response type discriminator. Added for centralized checkout flow. */
+    type?: 'checkout' | 'trial_started' | 'existing';
+    success: boolean;
+    checkoutUrl: string;
+    sessionId: string;
+    message: string;
+    planVersion?: {
+        _id: string;
+        version: number;
+        name: string;
+    };
+}
+/** No-card trial started server-side; no redirect needed. */
+interface ICheckoutTrialResult {
+    type: 'trial_started';
+    success: boolean;
+    checkoutUrl: null;
+    sessionId: null;
+    subscription: ISubscription;
+    message: string;
+}
+/** Workspace already has a matching active subscription. */
+interface ICheckoutExistingResult {
+    type: 'existing';
+    success: boolean;
+    checkoutUrl: null;
+    sessionId: null;
+    message: string;
+    existingSubscription?: {
+        _id: string;
+        subscriptionStatus: string;
+        stripePriceId?: string;
+    };
+}
+/**
+ * Discriminated union for POST /subscription/checkout responses.
+ * - `checkout`: Stripe checkout session created, redirect user to checkoutUrl
+ * - `trial_started`: No-card trial started server-side, no redirect needed
+ * - `existing`: Workspace already has a matching subscription
+ */
+type CheckoutResult = (ICheckoutSessionResponse & {
+    type: 'checkout';
+}) | ICheckoutTrialResult | ICheckoutExistingResult;
+/** Request body for PATCH .../workspaces/:id/subscription. Only these fields are allowed. */
+interface ISubscriptionUpdateRequest {
+    planVersionId: string;
+    billingInterval?: BillingInterval;
+    successUrl?: string;
+    cancelUrl?: string;
+}
+interface ISubscriptionUpdateResponse {
+    _id: string;
+    subscriptionStatus: string;
+    workspace: string;
+    planVersion: string;
+    plan: string;
+    planGroup?: string;
+    planGroupVersion?: string;
+    cancelAtPeriodEnd: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface IPublicPlanItemCategory {
+    name: string;
+    slug: string;
+}
+interface IPublicPlanItem {
+    _id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    type: 'feature' | 'limit' | 'quota';
+    category: IPublicPlanItemCategory;
+}
+/**
+ * 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';
+    /** 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 {
+    id: string;
+    amount_due: number;
+    number: string | null;
+    amount_paid: number;
+    currency: string;
+    status: InvoiceStatus;
+    created: number;
+    due_date: number | null;
+    hosted_invoice_url: string;
+    invoice_pdf: string | null;
+    description: string | null;
+    subscription: string;
+}
+interface IInvoiceListResponse {
+    success: boolean;
+    invoices: IInvoice[];
+    has_more: boolean;
+}
+interface IInvoiceResponse {
+    success: boolean;
+    invoice: IInvoice;
+}
+/** Request body for POST .../workspaces/:id/subscription/usage */
+interface IRecordUsageRequest {
+    quotaSlug: string;
+    quantity: number;
+    metadata?: Record<string, unknown>;
+    source?: string;
+    idempotencyKey?: string;
+}
+/** Response from POST .../workspaces/:id/subscription/usage */
+interface IRecordUsageResponse {
+    used: number;
+    consumed: number;
+    included: number;
+    available: number;
+    overage: number;
+    billedAsync: boolean;
+}
+/** Single quota usage status (shared between status and all endpoints). */
+interface IQuotaUsageStatus {
+    consumed: number;
+    included: number;
+    available: number;
+    overage: number;
+    hasOverage: boolean;
+}
+/** Response from GET .../workspaces/:id/subscription/usage/status?quotaSlug=X */
+interface IQuotaUsageStatusResponse extends IQuotaUsageStatus {
+    quotaSlug: string;
+}
+/** Response from GET .../workspaces/:id/subscription/usage/all */
+interface IAllQuotaUsageResponse {
+    quotas: Record<string, IQuotaUsageStatus>;
+}
+/** Single usage log entry from GET .../usage/logs */
+interface IUsageLogEntry {
+    _id: string;
+    quotaSlug: string;
+    quantity: number;
+    source?: string;
+    workspace: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Query parameters for GET .../workspaces/:id/subscription/usage/logs */
+interface IUsageLogsQuery {
+    quotaSlug?: string;
+    from?: string;
+    to?: string;
+    source?: string;
+    page?: number;
+    limit?: number;
+}
+/** Paginated response from GET .../workspaces/:id/subscription/usage/logs */
+interface IUsageLogsResponse {
+    docs: IUsageLogEntry[];
+    totalDocs: number;
+    limit: number;
+    page: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+}
+
+interface IWorkspace {
+    _id: string;
+    name: string;
+    image?: string;
+    workspaceId: string;
+    users: IUser[];
+    roles: string[];
+    createdBy: string | IUser;
+    features: Record<string, boolean>;
+    /**
+     * 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;
+    /** Workspace onboarding config. Set on creation based on org settings. SDK shows trial CTA. */
+    pendingOnboarding?: {
+        mode: 'trial';
+        planVersionId: string;
+    } | null;
+}
+interface IWorkspaceFeature {
+    _id: string;
+    name: string;
+    description: string;
+    userManaged: boolean;
+    defaultValue: boolean;
+    slug: string;
+    category: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface IWorkspaceUser {
+    _id: string;
+    workspace: string | IWorkspace;
+    user: string | IUser;
+    role: string;
+}
+
+/**
+ * Event types for all SDK events
+ */
+type EventType = 'user:created' | 'user:updated' | 'workspace:changed' | 'workspace:updated' | 'workspace:user-added' | 'workspace:user-removed' | 'workspace:user-role-changed' | 'workspace:created' | 'workspace:deleted';
+/**
+ * Event data types for each event
+ */
+interface UserCreatedEventData {
+    user: IUser;
+}
+interface UserUpdatedEventData {
+    user: IUser;
+    previousUser?: IUser;
+}
+interface WorkspaceChangedEventData {
+    workspace: IWorkspace;
+    previousWorkspace?: IWorkspace | null;
+}
+interface WorkspaceUpdatedEventData {
+    workspace: IWorkspace;
+}
+interface WorkspaceUserAddedEventData {
+    userId: string;
+    workspace: IWorkspace;
+    role: string;
+}
+interface WorkspaceUserRemovedEventData {
+    userId: string;
+    workspace: IWorkspace;
+    role: string;
+}
+interface WorkspaceUserRoleChangedEventData {
+    userId: string;
+    workspace: IWorkspace;
+    previousRole: string;
+    newRole: string;
+}
+interface WorkspaceCreatedEventData {
+    workspace: IWorkspace;
+}
+interface WorkspaceDeletedEventData {
+    workspace: IWorkspace;
+}
+/**
+ * Union type for all event data
+ */
+type EventData = UserCreatedEventData | UserUpdatedEventData | WorkspaceChangedEventData | WorkspaceUpdatedEventData | WorkspaceUserAddedEventData | WorkspaceUserRemovedEventData | WorkspaceUserRoleChangedEventData | WorkspaceCreatedEventData | WorkspaceDeletedEventData;
+/**
+ * Single event callback function
+ * Handles all events with conditional logic based on event type
+ */
+interface IEventCallbacks {
+    /**
+     * Called when any event occurs
+     * @param eventType - The type of event that occurred
+     * @param data - The event data (type varies based on eventType)
+     */
+    handleEvent?: (eventType: EventType, data: EventData) => void | Promise<void>;
+}
+
+declare enum AuthStatus {
+    loading = "loading",
+    redirecting = "redirecting",
+    authenticated = "authenticated",
+    unauthenticated = "unauthenticated",
+    authenticating = "authenticating"
+}
+interface AuthUser {
+    id: string;
+    name: string;
+    org: string;
+    email: string;
+    emailVerified: boolean;
+    clientId: string;
+    role: string;
+    image?: string;
+}
+interface AuthSession {
+    user: AuthUser;
+    sessionId: string;
+    expires: string;
+}
+interface IAuthConfig {
+    clientId: string;
+    redirectUrl: string;
+    callbacks?: IAuthCallbacks;
+}
+interface IAuthCallbacks {
+    handleAuthentication: (code: string) => Promise<{
+        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
+     * @param data - The event data (type varies based on eventType)
+     */
+    handleEvent?: (eventType: EventType, data: EventData) => void | Promise<void>;
+    /**
+     * Called before switching workspace (e.g. generate token, save state).
+     * Used when user clicks "Switch to" and when restoring from storage on page refresh.
+     * Switch proceeds only when this resolves; reject to abort.
+     */
+    onWorkspaceChange?: (params: OnWorkspaceChangeParams) => Promise<void>;
+}
+interface OnWorkspaceChangeParams {
+    workspace: IWorkspace;
+    user: AuthUser | null;
+    role: string | null;
+}
+
+interface ISettings {
+    workspace: {
+        roles: string[];
+        defaultRole: string;
+        maxWorkspaces: number;
+        maxWorkspaceUsers: number;
+    };
+    [key: string]: any;
+}
+
+/**
+ * Supported API versions
+ */
+declare enum ApiVersion {
+    V1 = "v1"
+}
+interface IOsConfig {
+    serverUrl: string;
+    version: ApiVersion;
+    orgId: string;
+}
+interface IOsState extends IOsConfig {
+    auth?: IAuthConfig;
+    settings?: ISettings | null;
+}
+
+/**
+ * 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.
+ *
+ * Supports two auth modes:
+ * 1. **Client-side (default):** reads sessionId from localStorage automatically.
+ * 2. **Server-side:** pass `sessionId` in config — no localStorage access.
+ *
+ * @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);
+ * ```
+ */
+
+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;
+}
+/**
+ * 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;
+    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>;
+}
+
+/**
+ * API client for authentication.
+ * Extends BaseApi for shared URL/auth/request handling.
+ */
+
+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>;
+}
+
+interface IScreenDetail {
+    title: string;
+    description: string;
+}
+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;
+    };
+}
+
+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>;
+}
+
+/**
+ * Centralized API client for organization (OS) settings.
+ * Extends BaseApi for shared URL/auth/request handling.
+ */
+
+declare class SettingsApi extends BaseApi {
+    constructor(config: IOsConfig & {
+        sessionId?: string;
+    });
+    getSettings(signal?: AbortSignal): Promise<ISettings>;
+}
+
+/**
+ * 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'> & {
+        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>>;
+}
+
+declare class WorkspaceApi extends BaseApi {
+    constructor(config: IOsConfig & {
+        sessionId?: string;
+    });
+    getWorkspaces(): Promise<IWorkspace[]>;
+    createWorkspace(data: {
+        name: string;
+        image?: string;
+    }): Promise<IWorkspace>;
+    updateWorkspace(id: string, data: Partial<IWorkspace>): Promise<IWorkspace>;
+    deleteWorkspace(id: string): Promise<{
+        success: boolean;
+    }>;
+    getWorkspaceUsers(workspaceId: string): Promise<IWorkspaceUser[]>;
+    addUser(workspaceId: string, config: {
+        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, data: Partial<IWorkspaceUser>): Promise<{
+        userId: string;
+        workspace: IWorkspace;
+        message: string;
+    }>;
+    getFeatures(): Promise<IWorkspaceFeature[]>;
+    updateFeature(workspaceId: string, key: string, value: boolean): Promise<IWorkspace>;
+    getWorkspace(workspaceId: string): Promise<IWorkspace>;
+    getProfile(): Promise<IUser>;
+    updateUserProfile(config: Partial<IUser>): Promise<IUser>;
+    /**
+     * Get current subscription for a workspace
+     * Returns subscription details including plan, plan version, and group information
+     */
+    getCurrentSubscription(workspaceId: string): Promise<ISubscriptionResponse>;
+    /**
+     * Get plan group for a workspace
+     * Returns the plan group containing the current plan if subscription exists,
+     * otherwise returns the latest published group
+     */
+    getPlanGroup(workspaceId: string): Promise<IPlanGroupResponse>;
+    /**
+     * Get plan group for a workspace with a specific version
+     * @param workspaceId - The workspace ID
+     * @param groupVersionId - The plan group version ID to fetch
+     * @returns Plan group response with the specified version
+     */
+    getPlanGroupByVersion(workspaceId: string, groupVersionId: string): Promise<IPlanGroupResponse>;
+    /**
+     * Get current group version and available newer versions of the same group
+     * - If user has active subscription: returns their current group version + newer versions
+     * - If no subscription: returns the latest published group version
+     * Shows what's new in newer versions to help users upgrade
+     * Example: User on Group v1 (Basic Plan) can see Group v2 (Basic + Pro Plan)
+     * @param workspaceId - The workspace ID
+     * @returns Plan group versions response with currentVersion and availableVersions
+     */
+    getPlanGroupVersions(workspaceId: string): Promise<IPlanGroupVersionsResponse>;
+    /**
+     * Get plan group versions by slug (public, no auth required).
+     * Returns the latest published plan group versions for the given plan group slug.
+     * Use this for public pricing pages when you want to show a specific plan group.
+     *
+     * @param slug - Plan group slug (e.g. 'default', 'enterprise')
+     * @returns Plan group versions response with currentVersion and availableVersions
+     */
+    getPublicPlans(slug: string): Promise<IPublicPlansResponse>;
+    /**
+     * Get plan group version details by ID (public, no auth required).
+     * Returns the full plan group version with populated plan versions.
+     * 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
+     * @returns Plan group version with populated plan versions
+     */
+    getPlanGroupVersion(groupVersionId: string): Promise<IPlanGroupVersion>;
+    /**
+     * Create checkout session for new subscription
+     * @param workspaceId - The workspace ID
+     * @param request - Checkout session request with planVersionId and optional billing interval/URLs
+     * @returns Checkout session response with checkoutUrl to redirect user
+     */
+    createCheckoutSession(workspaceId: string, request: ICheckoutSessionRequest): Promise<CheckoutResult>;
+    /**
+     * Update subscription (upgrade/downgrade)
+     * Only allows plan changes within the same plan group
+     * Returns checkout session if payment is required, otherwise returns subscription update response
+     */
+    updateSubscription(workspaceId: string, request: ISubscriptionUpdateRequest): Promise<ISubscriptionUpdateResponse | ICheckoutSessionResponse>;
+    /**
+     * 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>;
+}
+
+/**
+ * EventEmitter class to handle and trigger event callbacks
+ * This class manages all event listeners and provides methods to trigger events
+ */
+declare class EventEmitter {
+    private callbacks;
+    /**
+     * Set the event callbacks
+     * @param callbacks - The event callbacks to register
+     */
+    setCallbacks(callbacks: IEventCallbacks | null): void;
+    /**
+     * Get the current event callbacks
+     * @returns The current event callbacks or null
+     */
+    getCallbacks(): IEventCallbacks | null;
+    /**
+     * Emit an event
+     * @param eventType - The type of event
+     * @param data - The event data
+     */
+    private emit;
+    /**
+     * Trigger user created event
+     * @param user - The newly created user
+     */
+    emitUserCreated(user: IUser): Promise<void>;
+    /**
+     * Trigger user updated event
+     * @param user - The updated user
+     * @param previousUser - The user data before the update (optional)
+     */
+    emitUserUpdated(user: IUser, previousUser?: IUser): Promise<void>;
+    /**
+     * Trigger workspace changed event
+     * @param workspace - The newly selected workspace
+     * @param previousWorkspace - The previously selected workspace (optional)
+     */
+    emitWorkspaceChanged(workspace: IWorkspace, previousWorkspace?: IWorkspace | null): Promise<void>;
+    /**
+     * Trigger workspace updated event
+     * @param workspace - The updated workspace
+     */
+    emitWorkspaceUpdated(workspace: IWorkspace): Promise<void>;
+    /**
+     * Trigger workspace user added event
+     * @param userId - The ID of the user that was added
+     * @param workspace - The workspace the user was added to
+     * @param role - The role assigned to the user
+     */
+    emitWorkspaceUserAdded(userId: string, workspace: IWorkspace, role: string): Promise<void>;
+    /**
+     * Trigger workspace user removed event
+     * @param userId - The ID of the user that was removed
+     * @param workspace - The workspace the user was removed from
+     * @param role - The role the user had in the workspace
+     */
+    emitWorkspaceUserRemoved(userId: string, workspace: IWorkspace, role: string): Promise<void>;
+    /**
+     * Trigger workspace user role changed event
+     * @param userId - The ID of the user whose role was changed
+     * @param workspace - The workspace where the role was changed
+     * @param previousRole - The previous role of the user
+     * @param newRole - The new role of the user
+     */
+    emitWorkspaceUserRoleChanged(userId: string, workspace: IWorkspace, previousRole: string, newRole: string): Promise<void>;
+    /**
+     * Trigger workspace created event
+     * @param workspace - The newly created workspace
+     */
+    emitWorkspaceCreated(workspace: IWorkspace): Promise<void>;
+    /**
+     * Trigger workspace deleted event
+     * @param workspace - The deleted workspace
+     */
+    emitWorkspaceDeleted(workspace: IWorkspace): Promise<void>;
+}
+declare const eventEmitter: EventEmitter;
+
+/**
+ * Notify all subscribers to refetch subscription (e.g. after update/cancel/resume).
+ * Called internally by useUpdateSubscription, useCancelSubscription, useResumeSubscription on success.
+ */
+declare function invalidateSubscription(): void;
+
+/**
+ * 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.
+ * 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;
+
+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).
+ */
+
+/** 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;
+/** Get per-seat pricing config for a plan version and currency. Null if not enabled. */
+declare function getSeatPricing(planVersion: IPlanVersion, currency: string): IPricingVariant['seatPricing'] | null;
+/** Get per-seat price in cents for a billing interval. Null if seat pricing not enabled. */
+declare function getPerSeatPriceCents(planVersion: IPlanVersion, currency: string, interval: BillingInterval): number | null;
+/** Calculate billable seats: max(0, currentSeats - includedSeats). */
+declare function calculateBillableSeats(currentSeatCount: number, includedSeats: number): number;
+/** Calculate total seat overage cost in cents. Null if seat pricing not enabled. */
+declare function calculateSeatOverageCents(planVersion: IPlanVersion, currency: string, interval: BillingInterval, currentSeatCount: number): number | null;
+/**
+ * Calculate total subscription price in cents: base + seat overage (if enabled).
+ * Does not include metered usage (billed at period end).
+ */
+declare function calculateTotalSubscriptionCents(planVersion: IPlanVersion, currency: string, interval: BillingInterval, currentSeatCount?: number): 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;
+}
+/**
+ * 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 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;
+}
+/**
+ * Validate whether a new member can be invited given current seat/user limits.
+ */
+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;
+}
+
+interface SaaSOSProviderProps extends IOsState {
+    children: react__default.ReactNode;
+}
+declare const SaaSOSProvider: react__default.FC<SaaSOSProviderProps>;
+
+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;
+};
+
+interface IProps$2 {
+    children: React.ReactNode;
+}
+/**
+ * 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>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare const WhenUnauthenticated: {
+    (props: IProps$2): react.ReactNode;
+    displayName: string;
+};
+
+interface IProps$1 {
+    roles: string[];
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+}
+/**
+ * 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>
+ *   );
+ * }
+ * ```
+ */
+declare const WhenWorkspaceRoles: {
+    (props: IProps$1): react.ReactNode;
+    displayName: string;
+};
+
+interface IProps {
+    slug: string;
+    children: React.ReactNode;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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>
+ * ```
+ */
+declare const WhenQuotaAvailable: {
+    (props: IWhenQuotaProps): react.ReactNode;
+    displayName: string;
+};
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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 once when OS config is ready.
+ * Safe to call from multiple components — only one fetch is made.
+ */
+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>;
+}
+
+/**
+ * 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 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;
+};
+
+/**
+ * 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 users allowed (resolved from seat pricing, plan limits, or settings). 0 = unlimited. */
+    maxUsers: number;
+    /**
+     * Maximum seats allowed from seat pricing config. 0 = unlimited.
+     * @deprecated Use `maxUsers` for the unified limit.
+     */
+    maxSeats: number;
+    /** Where the max user limit comes from. */
+    limitSource: MaxUsersConfig['source'];
+    /** 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/user 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;
+    /** Whether a new member can be invited. */
+    canInvite: boolean;
+    /** Reason the invite is blocked, or null if allowed. */
+    inviteBlockReason: InviteBlockReason;
+    /** Human-readable message for why invite is blocked. */
+    inviteBlockMessage: string | null;
+}
+/**
+ * Hook that computes seat status from subscription context and workspace data.
+ * Resolves max user limits from seat pricing, plan limits, and settings in priority order.
+ * Must be used within SubscriptionContextProvider.
+ *
+ * @param workspace - The current workspace (needs users array, limits, billingCurrency)
+ * @param options - Optional overrides (e.g. settingsMaxUsers fallback)
+ * @returns SeatStatus — computed seat and invite information
+ *
+ * @example
+ * ```tsx
+ * const { isAtMax, canInvite, inviteBlockMessage, availableSeats } = useSeatStatus(workspace);
+ *
+ * if (!canInvite) {
+ *   return <div>{inviteBlockMessage}</div>;
+ * }
+ * ```
+ */
+declare function useSeatStatus(workspace: {
+    users?: any[];
+    billingCurrency?: string | null;
+} | null, options?: {
+    settingsMaxUsers?: number | null;
+}): SeatStatus;
+
+declare function WorkspaceSwitcher(props: {
+    trigger: (isLoading: boolean, currentWorkspace: IWorkspace | null) => ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+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.
+ *
+ * @example
+ * ```tsx
+ * <PricingPage slug="main-pricing">
+ *   {({ loading, error, items, plans, refetch }) => {
+ *     if (loading) return <Loading />;
+ *     if (error) return <Error message={error} />;
+ *
+ *     return (
+ *       <div>
+ *         {plans.map(plan => (
+ *           <PlanCard key={plan._id} plan={plan} items={items} />
+ *         ))}
+ *       </div>
+ *     );
+ *   }}
+ * </PricingPage>
+ * ```
+ */
+declare function PricingPage({ slug, children, loadingFallback, errorFallback }: PricingPageProps): react_jsx_runtime.JSX.Element;
+
+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;
+
+export { ApiVersion, AuthApi, AuthStatus, BaseApi, BetaForm, CURRENCY_DISPLAY, CURRENCY_FLAG, EventEmitter, PLAN_CURRENCY_CODES, PLAN_CURRENCY_OPTIONS, PUSH_SERVICE_WORKER_SCRIPT, PricingPage, PushApi, 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, formSchema as betaFormSchema, calculateBillableSeats, calculateSeatOverageCents, calculateTotalSubscriptionCents, countries, uniqueCurrencies as currencies, 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, 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, validateInvite };
+export type { BetaFormData, BetaFormResponse, formValuesType as BetaFormValues, BillingInterval, CheckoutResult, EventData, EventType, 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, InvoiceStatus, MaxUsersConfig, OnWorkspaceChangeParams, PlanVersionWithPricingVariants, PricingPageDetails, PricingPageProps, QuotaDisplayValue, QuotaDisplayWithOverage, QuotaUsageContextValue, SaaSOSProviderProps, SeatStatus, SubscriptionContextValue, TrialStatus, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };