@buildbase/sdk 0.0.18 → 0.0.20

package/dist/index.d.ts

@@ -4,7 +4,8 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 
 interface IDocument {
     _id: string;
-    id: string;
+    /** Optional; some APIs only return _id. Prefer _id for identity. */
+    id?: string;
     createdAt: string;
     updatedAt: string;
     deleted: boolean;
@@ -13,12 +14,17 @@ interface IUser extends IDocument {
     _id: string;
     name: string;
     email: string;
-    image: string;
+    /** Profile image URL. Often omitted or empty from API. */
+    image?: string;
     role: string;
-    country: string;
-    timezone: string;
-    language: string;
-    currency: string;
+    /** ISO country code. May be omitted. */
+    country?: string;
+    /** IANA timezone. May be omitted. */
+    timezone?: string;
+    /** Language code. May be omitted. */
+    language?: string;
+    /** Currency code. May be omitted. */
+    currency?: string;
     attributes?: Record<string, string | number | boolean>;
 }
 type BillingInterval = 'monthly' | 'yearly' | 'quarterly';
@@ -36,6 +42,8 @@ interface ISubscription {
         name: string;
         slug: string;
         description?: string;
+        /** Stripe currency code (e.g. 'usd', 'inr', 'eur'). */
+        currency?: string;
     };
 }
 interface ISubscriptionItem {
@@ -46,17 +54,14 @@ interface ISubscriptionItem {
     description?: string;
     category: string;
 }
-interface IQuotaValue {
-    included: number;
-    overage?: number;
-    stripePriceId?: string;
-}
-/** Per-interval quota value (new plan-group/versions schema) */
+/** Per-interval quota value (plan-group/versions and public plans schema). */
 interface IQuotaIntervalValue {
     included: number;
-    overage: number;
-    priceId: string;
-    /** Optional unit size for overage pricing (e.g. 1000 = price per 1000 units). */
+    /** Overage price in cents. Omitted in public plans; use pricingVariant.quotaOverages for display. */
+    overage?: number;
+    /** Stripe price ID for overage. Omitted in public plans; use pricingVariant.quotaOveragePriceIds. */
+    priceId?: string;
+    /** Unit size for overage pricing (e.g. 1000 = price per 1000 units). */
     unitSize?: number;
 }
 /** Quota defined per billing interval (new plan-group/versions schema) */
@@ -65,11 +70,46 @@ interface IQuotaByInterval {
     yearly?: IQuotaIntervalValue;
     quarterly?: IQuotaIntervalValue;
 }
+/** Base pricing per interval. Values are often in cents (Stripe); convert for display. */
 interface IBasePricing {
     monthly: number;
     yearly: number;
     quarterly: number;
 }
+/** Stripe price IDs per billing interval (for a single currency variant). */
+interface IStripePricesByInterval {
+    monthlyPriceId?: string;
+    yearlyPriceId?: string;
+    quarterlyPriceId?: string;
+    monthly?: string;
+    yearly?: string;
+}
+/** Overage amounts in cents per interval, keyed by quota slug. Used in pricing variants. */
+type IQuotaOveragesByInterval = Record<string, {
+    monthly?: number;
+    yearly?: number;
+    quarterly?: number;
+}>;
+/** Overage Stripe price IDs per interval, keyed by quota slug. Used in pricing variants. */
+type IQuotaOveragePriceIdsByInterval = Record<string, {
+    monthly?: string;
+    yearly?: string;
+    quarterly?: string;
+}>;
+/**
+ * Multi-currency pricing variant at plan version level.
+ * Each plan version can have multiple variants (e.g. usd, eur, inr, sgd).
+ */
+interface IPricingVariant {
+    _id: string;
+    currency: string;
+    basePricing: IBasePricing;
+    stripePrices: IStripePricesByInterval;
+    /** Overage cents per quota slug per interval. */
+    quotaOverages?: IQuotaOveragesByInterval;
+    /** Stripe price IDs for overage per quota slug per interval. */
+    quotaOveragePriceIds?: IQuotaOveragePriceIdsByInterval;
+}
 interface IPlanVersion {
     _id: string;
     version: number;
@@ -77,16 +117,10 @@ interface IPlanVersion {
     status: 'draft' | 'published';
     features?: Record<string, boolean>;
     limits?: Record<string, number>;
-    /** Legacy: number | IQuotaValue. New schema: IQuotaByInterval (per-interval included/overage/priceId) */
-    quotas?: Record<string, number | IQuotaValue | IQuotaByInterval>;
-    basePricing?: IBasePricing;
-    stripePrices?: {
-        monthlyPriceId?: string;
-        yearlyPriceId?: string;
-        quarterlyPriceId?: string;
-        monthly?: string;
-        yearly?: string;
-    };
+    /** Per-interval quotas (included, unitSize; overage from pricingVariant.quotaOverages). */
+    quotas?: Record<string, IQuotaByInterval>;
+    /** Multi-currency pricing. Each variant has currency, basePricing, stripePrices, quotaOverages. */
+    pricingVariants?: IPricingVariant[];
     subscriptionItems?: ISubscriptionItem[];
     isCurrent?: boolean;
     isLegacy?: boolean;
@@ -106,6 +140,8 @@ interface IPlan {
     name: string;
     slug: string;
     description?: string;
+    /** Stripe currency code (e.g. 'usd', 'inr', 'eur'). Used for pricing display. */
+    currency?: string;
     latestVersion?: IPlanVersionSummary;
     archived?: boolean;
     deleted?: boolean;
@@ -166,13 +202,19 @@ interface ISubscriptionResponse {
     group: IPlanGroup | null;
     groupVersion: IPlanGroupVersion | null;
 }
+/** Plan version with nested plan info (name, slug, currency for display). */
 interface IPlanVersionWithPlan extends IPlanVersion {
     plan: IPlan;
 }
+/**
+ * Plan group version with full plan versions (for GET .../plan-group/versions).
+ * Each plan has plan, subscriptionItems, quotas (per-interval), pricingVariants.
+ */
 interface IPlanGroupVersionWithPlans {
     _id: string;
     version: number;
     description?: string;
+    /** Full plan versions with nested plan (name, slug, currency). */
     plans: IPlanVersionWithPlan[];
     isCurrent?: boolean;
     whatsNew?: {
@@ -189,21 +231,31 @@ interface IPlanGroupInfo {
 }
 /** Response from GET workspaces/:id/subscription/plan-group (and by version). */
 interface IPlanGroupResponse {
-    /** Plan group with latestVersion, archived, deleted, timestamps. */
-    group: IPlanGroup;
+    /** Plan group with latestVersion, archived, deleted, timestamps. May be null in some API responses. */
+    group: IPlanGroup | null;
     /** Current group version with populated planVersionIds (or IDs). */
     groupVersion: IPlanGroupVersion;
-    /** Full plan versions for display (subscriptionItems, basePricing, quotas, etc.). */
+    /** Full plan versions for display (subscriptionItems, pricingVariants, quotas). */
     plans: IPlanVersionWithPlan[];
 }
+/**
+ * Response from GET workspaces/:workspaceId/subscription/plan-group/versions.
+ * Group summary plus current and available group versions; each version has plans with
+ * per-interval quotas and pricingVariants.
+ */
 interface IPlanGroupVersionsResponse {
+    /** Plan group summary (_id, name, slug). */
     group: IPlanGroupInfo;
+    /** Current group version (user's version when subscribed, or latest published when not). */
     currentVersion: IPlanGroupVersionWithPlans;
+    /** Newer versions when user has subscription; empty when no subscription. */
     availableVersions: IPlanGroupVersionWithPlans[];
 }
+/** Request body for POST .../workspaces/:id/subscription/checkout. Only these fields are allowed. */
 interface ICheckoutSessionRequest {
     planVersionId: string;
     billingInterval?: BillingInterval;
+    currency?: string;
     successUrl?: string;
     cancelUrl?: string;
 }
@@ -218,6 +270,7 @@ interface ICheckoutSessionResponse {
         name: string;
     };
 }
+/** Request body for PATCH .../workspaces/:id/subscription. Only these fields are allowed. */
 interface ISubscriptionUpdateRequest {
     planVersionId: string;
     billingInterval?: BillingInterval;
@@ -244,33 +297,33 @@ interface IPublicPlanItem {
     _id: string;
     name: string;
     slug: string;
-    description: string;
+    description?: string;
     type: 'feature' | 'limit' | 'quota';
     category: IPublicPlanItemCategory;
 }
-interface IPublicPlanPricing {
-    monthly: number;
-    yearly: number;
-    quarterly: number;
-}
-interface IPublicPlanQuotaValue {
-    included: number;
-    overage: number;
-    stripePriceId?: string;
-}
+/**
+ * Public plan version (e.g. from GET /api/v1/public/:orgId/plans/:slug).
+ * Each plan has _id, name (plan display name), version, status, pricingVariants, quotas, features, limits.
+ * Pricing is in cents (see response.notes).
+ */
 interface IPublicPlanVersion {
     _id: string;
+    /** Plan display name (e.g. "Pro", "Base Plan"). */
     name: string;
     version: number;
     status: 'draft' | 'published';
-    pricing: IPublicPlanPricing;
-    quotas: Record<string, IPublicPlanQuotaValue>;
+    /** Multi-currency pricing. Use getBasePriceCents(plan, currency, interval) and getQuotaDisplayWithVariant for display. */
+    pricingVariants?: IPricingVariant[];
+    /** Keyed by item slug. Per-interval: included, unitSize; overage from pricingVariant.quotaOverages. */
+    quotas: Record<string, IQuotaByInterval>;
     features: Record<string, boolean>;
     limits: Record<string, number>;
 }
 interface IPublicPlansResponse {
     items: IPublicPlanItem[];
     plans: IPublicPlanVersion[];
+    /** Optional note from API (e.g. "Pricing is in cents. Please convert to dollars for display."). */
+    notes?: string;
 }
 type InvoiceStatus = 'draft' | 'open' | 'paid' | 'uncollectible' | 'void';
 interface IInvoice {
@@ -296,6 +349,68 @@ 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;
@@ -306,7 +421,24 @@ interface IWorkspace {
     roles: string[];
     createdBy: string | IUser;
     features: Record<string, boolean>;
-    subscription?: ISubscription | null;
+    /**
+     * Quota usage tracking: { [quotaSlug]: number } – how much of each quota has been used.
+     */
+    quotas?: Record<string, number>;
+    /**
+     * Subscription limits snapshot: { [limitSlug]: number | null } – synced from subscription plan.
+     * Limits are maximum values (e.g. max-users, max-workspaces). Updated when subscription is assigned/updated.
+     */
+    limits?: Record<string, number | null>;
+    subscription?: ISubscription | string | null;
+    /** Stripe Customer ID for this workspace. */
+    stripeCustomerId?: string;
+    /**
+     * Billing currency locked for this workspace (set on first subscription).
+     * Stripe allows one currency per customer; all future subscriptions must use this currency.
+     * When set, subscription UI only shows/uses this currency.
+     */
+    billingCurrency?: string | null;
 }
 interface IWorkspaceFeature {
     _id: string;
@@ -500,6 +632,8 @@ interface PricingPageDetails {
     items: IPublicPlanItem[];
     /** Plan versions with pricing, features, limits, quotas */
     plans: IPublicPlanVersion[];
+    /** Optional note from API (e.g. "Pricing is in cents. Please convert to dollars for display.") */
+    notes?: string;
     /** Refetch plan data */
     refetch: () => Promise<void>;
 }
@@ -563,7 +697,10 @@ interface IProps$2 {
  * }
  * ```
  */
-declare const WhenAuthenticated: (props: IProps$2) => react.ReactNode;
+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.
@@ -605,7 +742,10 @@ declare const WhenAuthenticated: (props: IProps$2) => react.ReactNode;
  * }
  * ```
  */
-declare const WhenUnauthenticated: (props: IProps$2) => react.ReactNode;
+declare const WhenUnauthenticated: {
+    (props: IProps$2): react.ReactNode;
+    displayName: string;
+};
 
 interface IProps$1 {
     roles: string[];
@@ -647,7 +787,10 @@ interface IProps$1 {
  * }
  * ```
  */
-declare const WhenRoles: (props: IProps$1) => react.ReactNode;
+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.
@@ -683,7 +826,10 @@ declare const WhenRoles: (props: IProps$1) => react.ReactNode;
  * }
  * ```
  */
-declare const WhenWorkspaceRoles: (props: IProps$1) => react.ReactNode;
+declare const WhenWorkspaceRoles: {
+    (props: IProps$1): react.ReactNode;
+    displayName: string;
+};
 
 interface IProps {
     slug: string;
@@ -725,7 +871,10 @@ interface IProps {
  * }
  * ```
  */
-declare const WhenWorkspaceFeatureEnabled: (props: IProps) => react.ReactNode;
+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.
@@ -745,7 +894,10 @@ declare const WhenWorkspaceFeatureEnabled: (props: IProps) => react.ReactNode;
  * }
  * ```
  */
-declare const WhenWorkspaceFeatureDisabled: (props: IProps) => react.ReactNode;
+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).
@@ -781,7 +933,10 @@ declare const WhenWorkspaceFeatureDisabled: (props: IProps) => react.ReactNode;
  * }
  * ```
  */
-declare const WhenUserFeatureEnabled: (props: IProps) => react.ReactNode;
+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).
@@ -801,7 +956,10 @@ declare const WhenUserFeatureEnabled: (props: IProps) => react.ReactNode;
  * }
  * ```
  */
-declare const WhenUserFeatureDisabled: (props: IProps) => react.ReactNode;
+declare const WhenUserFeatureDisabled: {
+    (props: IProps): react.ReactNode;
+    displayName: string;
+};
 
 interface IWhenSubscriptionProps {
     /** Content to render when the condition is met (workspace has an active subscription). */
@@ -839,7 +997,10 @@ interface IWhenSubscriptionProps {
  * </WhenSubscription>
  * ```
  */
-declare const WhenSubscription: (props: IWhenSubscriptionProps) => react.ReactNode;
+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).
@@ -868,7 +1029,10 @@ declare const WhenSubscription: (props: IWhenSubscriptionProps) => react.ReactNo
  * </WhenNoSubscription>
  * ```
  */
-declare const WhenNoSubscription: (props: IWhenSubscriptionProps) => react.ReactNode;
+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[];
@@ -909,7 +1073,131 @@ interface IWhenSubscriptionToPlansProps {
  * </WhenSubscriptionToPlans>
  * ```
  */
-declare const WhenSubscriptionToPlans: (props: IWhenSubscriptionToPlansProps) => react.ReactNode;
+declare const WhenSubscriptionToPlans: {
+    (props: IWhenSubscriptionToPlansProps): 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.
@@ -919,6 +1207,8 @@ interface SubscriptionContextValue {
     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>;
 }
@@ -944,6 +1234,53 @@ declare const SubscriptionContextProvider: react__default.FC<{
  */
 declare function useSubscriptionContext(): SubscriptionContextValue;
 
+/**
+ * Notify all subscribers to refetch subscription (e.g. after update/cancel/resume).
+ * Called internally by useUpdateSubscription, useCancelSubscription, useResumeSubscription on success.
+ */
+declare function invalidateSubscription(): void;
+
+/**
+ * Value provided by QuotaUsageContext and returned by useQuotaUsageContext.
+ */
+interface QuotaUsageContextValue {
+    /** Current quota usage statuses keyed by slug, or null if not loaded. */
+    quotas: Record<string, IQuotaUsageStatus> | null;
+    /** True while quota usage is being fetched. */
+    loading: boolean;
+    /** Error message if the last fetch failed, or null. */
+    error: string | null;
+    /** Refetch all quota usage for the current workspace. Call after recording usage or when usage was updated elsewhere. */
+    refetch: () => Promise<void>;
+}
+
+/**
+ * Provides quota usage data for the current workspace to quota gate components.
+ * Fetches when workspace changes; refetches when quota usage is invalidated (e.g. after recording usage).
+ * Must wrap (or be ancestor of) any component that uses WhenQuotaAvailable, WhenQuotaExhausted,
+ * WhenQuotaOverage, WhenQuotaThreshold, or useQuotaUsageContext. Included in SaaSOSProvider by default.
+ *
+ * @param props - Component props
+ * @param props.children - React tree that may use quota gates or useQuotaUsageContext
+ * @returns Provider element that supplies quota usage context to descendants
+ */
+declare const QuotaUsageContextProvider: react__default.FC<{
+    children: ReactNode;
+}>;
+/**
+ * Returns quota usage data for the current workspace. Must be used within QuotaUsageContextProvider.
+ *
+ * @returns QuotaUsageContextValue - { quotas, loading, refetch }
+ * @throws Error if used outside QuotaUsageContextProvider
+ */
+declare function useQuotaUsageContext(): QuotaUsageContextValue;
+
+/**
+ * Notify all subscribers to refetch quota usage (e.g. after recording usage).
+ * Called internally by useRecordUsage on success.
+ */
+declare function invalidateQuotaUsage(): void;
+
 type WorkspaceSettingsSection = 'profile' | 'general' | 'users' | 'subscription' | 'features' | 'danger';
 
 declare function useSaaSAuth(): {
@@ -1283,6 +1620,33 @@ declare class WorkspaceApi extends BaseApi {
      * @returns Updated subscription with cancelAtPeriodEnd set to false
      */
     resumeSubscription(workspaceId: string): Promise<ISubscriptionResponse>;
+    /**
+     * Record quota usage for a workspace
+     * @param workspaceId - The workspace ID
+     * @param request - Usage request with quotaSlug, quantity, and optional metadata/source
+     * @returns Usage result with consumed/included/available/overage
+     */
+    recordUsage(workspaceId: string, request: IRecordUsageRequest): Promise<IRecordUsageResponse>;
+    /**
+     * Get usage status for a single quota
+     * @param workspaceId - The workspace ID
+     * @param quotaSlug - The quota slug to check
+     * @returns Quota usage status with consumed/included/available/overage/hasOverage
+     */
+    getQuotaUsageStatus(workspaceId: string, quotaSlug: string): Promise<IQuotaUsageStatusResponse>;
+    /**
+     * Get usage status for all quotas in the workspace's current plan
+     * @param workspaceId - The workspace ID
+     * @returns All quota usage statuses keyed by quota slug
+     */
+    getAllQuotaUsage(workspaceId: string): Promise<IAllQuotaUsageResponse>;
+    /**
+     * Get paginated usage logs for a workspace
+     * @param workspaceId - The workspace ID
+     * @param query - Optional filters: quotaSlug, from, to, source, page, limit
+     * @returns Paginated usage log entries
+     */
+    getUsageLogs(workspaceId: string, query?: IUsageLogsQuery): Promise<IUsageLogsResponse>;
 }
 
 declare const useSaaSWorkspaces: () => {
@@ -1300,7 +1664,7 @@ declare const useSaaSWorkspaces: () => {
         forceEmit?: boolean;
     }) => Promise<void>;
     resetCurrentWorkspace: () => void;
-    createWorkspace: (name: string, image: string) => Promise<void>;
+    createWorkspace: (name: string, image?: string) => Promise<void>;
     allFeatures: IWorkspaceFeature[];
     getFeatures: () => Promise<IWorkspaceFeature[] | null>;
     updateFeature: (workspaceId: string, key: string, value: boolean) => Promise<IWorkspace>;
@@ -1346,6 +1710,7 @@ declare function WorkspaceSwitcher(props: {
 declare const usePublicPlans: (slug: string) => {
     items: IPublicPlanItem[];
     plans: IPublicPlanVersion[];
+    notes: string | undefined;
     loading: boolean;
     error: string | null;
     refetch: () => Promise<void>;
@@ -1816,6 +2181,264 @@ declare const useInvoice: (workspaceId: string | null | undefined, invoiceId: st
     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>;
+};
 
 /**
  * EventEmitter class to handle and trigger event callbacks
@@ -1906,23 +2529,122 @@ declare class SettingsApi extends BaseApi {
     getSettings(signal?: AbortSignal): Promise<ISettings>;
 }
 
+/**
+ * Centralized formatting for subscription/quota display: cents, overage rates, included + overage text.
+ * Currency must be provided by the caller (e.g. workspace.billingCurrency, plan.currency, or selected currency).
+ */
+/** Common currency display (code or symbol). Use lowercase Stripe codes (usd, eur, etc.). */
+declare const CURRENCY_DISPLAY: Record<string, string>;
+/** Currency code to flag emoji (country/region associated with the currency). Use for dropdowns. */
+declare const CURRENCY_FLAG: Record<string, string>;
+/** Get flag emoji for a currency code. Returns empty string when unknown or empty. */
+declare function getCurrencyFlag(currency: string): string;
+/** Get currency symbol for display. Use lowercase Stripe codes (usd, eur). Returns code when unknown; empty string when currency is empty. */
+declare function getCurrencySymbol(currency: string): string;
+/** Allowed plan/pricing currency codes (must match server ALLOWED_BILLING_CURRENCIES). Use for dropdowns and validation. */
+declare const PLAN_CURRENCY_CODES: readonly ["usd", "eur", "gbp", "jpy", "cad", "aud", "chf", "cny", "hkd", "sgd", "inr", "mxn", "brl", "nzd", "sek", "nok", "dkk", "pln", "thb"];
+/** Options for plan currency select: { value, label } with symbol. Use in CreateOrEditPlan and anywhere a currency dropdown is needed. */
+declare const PLAN_CURRENCY_OPTIONS: {
+    value: "usd" | "eur" | "gbp" | "jpy" | "cad" | "aud" | "chf" | "cny" | "hkd" | "sgd" | "inr" | "mxn" | "brl" | "nzd" | "sek" | "nok" | "dkk" | "pln" | "thb";
+    label: string;
+}[];
+/** Format cents as money string (e.g. 1999, "usd" -> "$19.99"). Caller must pass currency (e.g. from plan or workspace). */
+declare function formatCents(cents: number, currency: string): string;
+/**
+ * Format overage rate for display. When unitSize > 1: "$1.00/1,000 units"; else "$1.00/unit".
+ * Returns null if overageCents is missing or negative.
+ */
+declare function formatOverageRate(overageCents: number | undefined, unitSize: number | undefined, currency: string): string | null;
+/**
+ * Format overage rate with optional unit label for comparison/preview UIs.
+ * e.g. formatOverageRateWithLabel(50, 1000, "video") -> "$0.50/1,000 videos"
+ *      formatOverageRateWithLabel(46, 1, "video") -> "$0.46/video"
+ * When unitLabel is omitted, falls back to formatOverageRate behavior.
+ */
+declare function formatOverageRateWithLabel(overageCents: number | undefined, unitSize: number | undefined, unitLabel: string | undefined, currency: string): string | null;
+/**
+ * Get singular unit label from item name or slug (e.g. "Videos" -> "video", "reels" -> "reel").
+ * Used for quota display in comparison and preview.
+ */
+declare function getQuotaUnitLabelFromName(nameOrSlug: string): string;
+/**
+ * Format quota "included + overage" for display.
+ * When unitSize >= 2: "Included: 1,000, after that $1.00/1,000 emails".
+ * Otherwise: "Included: 5, after that $0.30/image".
+ */
+declare function formatQuotaIncludedOverage(included: number | undefined, overageCents: number | undefined, unitLabel: string, currency: string, unitSize?: number): string;
+
+/**
+ * Helpers for multi-currency plan version pricing (pricingVariants).
+ */
+
+/** Get the pricing variant for a currency, or null if not available. */
+declare function getPricingVariant(planVersion: IPlanVersion, currency: string): IPricingVariant | null;
+/**
+ * Get base price in cents for a plan version and currency/interval.
+ */
+declare function getBasePriceCents(planVersion: IPlanVersion, currency: string, interval: BillingInterval): number | null;
+/**
+ * Get Stripe price ID for the given plan version, currency, and interval.
+ */
+declare function getStripePriceIdForInterval(planVersion: IPlanVersion, currency: string, interval: BillingInterval): string | null;
+/**
+ * Get overage amount in cents for a quota in a given currency and interval.
+ * Returns undefined if not defined in the pricing variant.
+ */
+declare function getQuotaOverageCents(planVersion: IPlanVersion, currency: string, quotaSlug: string, interval: BillingInterval): number | undefined;
+/**
+ * Get display currency for a plan version when using a given currency.
+ * Returns the requested currency if the variant exists; otherwise plan.currency or null.
+ */
+declare function getDisplayCurrency(planVersion: IPlanVersionWithPlan, currency: string): string;
+/** Minimal shape for extracting currencies (IPlanVersionWithPlan or IPublicPlanVersion). */
+type PlanVersionWithPricingVariants = {
+    pricingVariants?: IPricingVariant[];
+};
+/**
+ * Collect all unique currency codes from plan versions (from their pricingVariants).
+ * Use for currency selector. Accepts IPlanVersionWithPlan[] or IPublicPlanVersion[].
+ */
+declare function getAvailableCurrenciesFromPlans(planVersions: PlanVersionWithPricingVariants[]): string[];
+/**
+ * Quota display shape: included count and optional overage (cents) and unitSize from plan + variant.
+ */
+type QuotaDisplayWithOverage = {
+    included: number;
+    overage?: number;
+    unitSize?: number;
+} | null;
+/**
+ * Get quota display value for a slug/interval, merging plan version quotas (included, unitSize)
+ * with pricing variant overage (cents) when available.
+ */
+declare function getQuotaDisplayWithVariant(planVersion: IPlanVersion, currency: string, quotaSlug: string, interval: BillingInterval): QuotaDisplayWithOverage;
+/**
+ * Resolve billing interval and currency from a Stripe price ID by checking all plan versions' pricingVariants.
+ */
+declare function getBillingIntervalAndCurrencyFromPriceId(priceId: string | null | undefined, planVersions: IPlanVersionWithPlan[]): {
+    interval: BillingInterval;
+    currency: string;
+} | null;
+
 type QuotaDisplayValue = {
     included: number;
     overage?: number;
     unitSize?: number;
-} | number | null;
+} | null;
 /**
- * Normalize a quota value (legacy or per-interval) to a display shape for a given billing interval.
- * - Legacy: number or IQuotaValue → use as-is (interval ignored).
- * - New schema: IQuotaByInterval → pick the interval slice (e.g. monthly, yearly, quarterly).
+ * Normalize a per-interval quota value to a display shape for the given billing interval.
  */
-declare function getQuotaDisplayValue(value: number | IQuotaValue | IQuotaByInterval | null | undefined, interval?: BillingInterval): QuotaDisplayValue;
+declare function getQuotaDisplayValue(value: IQuotaByInterval | null | undefined, interval?: BillingInterval): QuotaDisplayValue;
 /** Options for formatting quota with price. */
 interface FormatQuotaWithPriceOptions {
     /** If true, overage is in cents (Stripe); format as dollars. Default true. */
     overageInCents?: boolean;
-    /** Currency symbol. Default '$'. */
+    /** Currency symbol override. When omitted, derived from `currency` (empty if no currency). */
     currencySymbol?: string;
+    /** Stripe currency code (e.g. 'usd', 'inr'). Used to resolve symbol when currencySymbol is not set. */
+    currency?: string;
 }
 /**
  * Format a quota display value as "X included, then $Y.YY / unit" (e.g. "10 included, then $10.00 / video").
@@ -1930,5 +2652,5 @@ interface FormatQuotaWithPriceOptions {
  */
 declare function formatQuotaWithPrice(value: QuotaDisplayValue, unitName: string, options?: FormatQuotaWithPriceOptions): string;
 
-export { ApiVersion, AuthStatus, BaseApi, BetaForm, PricingPage, SaaSOSProvider, SettingsApi, SubscriptionContextProvider, UserApi, WhenAuthenticated, WhenNoSubscription, WhenRoles, WhenSubscription, WhenSubscriptionToPlans, WhenUnauthenticated, WhenUserFeatureDisabled, WhenUserFeatureEnabled, WhenWorkspaceFeatureDisabled, WhenWorkspaceFeatureEnabled, WhenWorkspaceRoles, WorkspaceApi, WorkspaceSwitcher, eventEmitter, formatQuotaWithPrice, getQuotaDisplayValue, useCreateCheckoutSession, useInvoice, useInvoices, usePlanGroup, usePlanGroupVersions, usePublicPlanGroupVersion, usePublicPlans, useSaaSAuth, useSaaSOs, useSaaSSettings, useSaaSWorkspaces, useSubscription, useSubscriptionContext, useSubscriptionManagement, useUpdateSubscription, useUserAttributes, useUserFeatures };
-export type { BillingInterval, EventData, EventType, FormatQuotaWithPriceOptions, IBaseApiConfig, IBasePricing, ICheckoutSessionRequest, ICheckoutSessionResponse, IEventCallbacks, IInvoice, IInvoiceListResponse, IInvoiceResponse, IPlan, IPlanGroup, IPlanGroupInfo, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionWithPlans, IPlanGroupVersionsResponse, IPlanVersion, IPlanVersionSummary, IPlanVersionWithPlan, IPublicPlanItem, IPublicPlanItemCategory, IPublicPlanPricing, IPublicPlanQuotaValue, IPublicPlanVersion, IPublicPlansResponse, IQuotaByInterval, IQuotaIntervalValue, IQuotaValue, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, InvoiceStatus, OnWorkspaceChangeParams, PricingPageDetails, PricingPageProps, QuotaDisplayValue, SubscriptionContextValue, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };
+export { ApiVersion, AuthStatus, BaseApi, BetaForm, CURRENCY_DISPLAY, CURRENCY_FLAG, PLAN_CURRENCY_CODES, PLAN_CURRENCY_OPTIONS, PricingPage, QuotaUsageContextProvider, SaaSOSProvider, SettingsApi, SubscriptionContextProvider, UserApi, WhenAuthenticated, WhenNoSubscription, WhenQuotaAvailable, WhenQuotaExhausted, WhenQuotaOverage, WhenQuotaThreshold, WhenRoles, WhenSubscription, WhenSubscriptionToPlans, WhenUnauthenticated, WhenUserFeatureDisabled, WhenUserFeatureEnabled, WhenWorkspaceFeatureDisabled, WhenWorkspaceFeatureEnabled, WhenWorkspaceRoles, WorkspaceApi, WorkspaceSwitcher, eventEmitter, formatCents, formatOverageRate, formatOverageRateWithLabel, formatQuotaIncludedOverage, formatQuotaWithPrice, getAvailableCurrenciesFromPlans, getBasePriceCents, getBillingIntervalAndCurrencyFromPriceId, getCurrencyFlag, getCurrencySymbol, getDisplayCurrency, getPricingVariant, getQuotaDisplayValue, getQuotaDisplayWithVariant, getQuotaOverageCents, getQuotaUnitLabelFromName, getStripePriceIdForInterval, invalidateQuotaUsage, invalidateSubscription, useAllQuotaUsage, useCancelSubscription, useCreateCheckoutSession, useInvoice, useInvoices, usePlanGroup, usePlanGroupVersions, usePublicPlanGroupVersion, usePublicPlans, useQuotaUsageContext, useQuotaUsageStatus, useRecordUsage, useResumeSubscription, useSaaSAuth, useSaaSOs, useSaaSSettings, useSaaSWorkspaces, useSubscription, useSubscriptionContext, useSubscriptionManagement, useUpdateSubscription, useUsageLogs, useUserAttributes, useUserFeatures };
+export type { BillingInterval, EventData, EventType, FormatQuotaWithPriceOptions, IAllQuotaUsageResponse, IBaseApiConfig, IBasePricing, ICheckoutSessionRequest, ICheckoutSessionResponse, IEventCallbacks, IInvoice, IInvoiceListResponse, IInvoiceResponse, IPlan, IPlanGroup, IPlanGroupInfo, IPlanGroupLatestVersion, IPlanGroupResponse, IPlanGroupVersion, IPlanGroupVersionWithPlans, IPlanGroupVersionsResponse, IPlanVersion, IPlanVersionSummary, IPlanVersionWithPlan, IPricingVariant, IPublicPlanItem, IPublicPlanItemCategory, IPublicPlanVersion, IPublicPlansResponse, IQuotaByInterval, IQuotaIntervalValue, IQuotaOveragePriceIdsByInterval, IQuotaOveragesByInterval, IQuotaUsageStatus, IQuotaUsageStatusResponse, IRecordUsageRequest, IRecordUsageResponse, IStripePricesByInterval, ISubscription, ISubscriptionItem, ISubscriptionResponse, ISubscriptionUpdateRequest, ISubscriptionUpdateResponse, IUsageLogEntry, IUsageLogsQuery, IUsageLogsResponse, InvoiceStatus, OnWorkspaceChangeParams, PlanVersionWithPricingVariants, PricingPageDetails, PricingPageProps, QuotaDisplayValue, QuotaDisplayWithOverage, QuotaUsageContextValue, SubscriptionContextValue, UserCreatedEventData, UserUpdatedEventData, WorkspaceChangedEventData, WorkspaceCreatedEventData, WorkspaceDeletedEventData, WorkspaceUpdatedEventData, WorkspaceUserAddedEventData, WorkspaceUserRemovedEventData, WorkspaceUserRoleChangedEventData };