@billingos/sdk 0.1.2 → 0.1.4

package/dist/index.d.cts

@@ -0,0 +1,3085 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, UseMutationOptions, QueryClient } from '@tanstack/react-query';
+export { useQueryClient as useBillingOSQueryClient } from '@tanstack/react-query';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as React$1 from 'react';
+import React__default from 'react';
+import { VariantProps } from 'class-variance-authority';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ClassValue } from 'clsx';
+
+/**
+ * Customer represents a billing customer
+ */
+interface Customer {
+    id: string;
+    email: string;
+    name?: string;
+    metadata?: Record<string, string>;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Input for creating a customer
+ */
+interface CreateCustomerInput {
+    email: string;
+    name?: string;
+    metadata?: Record<string, string>;
+}
+/**
+ * Input for updating a customer
+ */
+interface UpdateCustomerInput {
+    email?: string;
+    name?: string;
+    metadata?: Record<string, string>;
+}
+/**
+ * Subscription status
+ */
+type SubscriptionStatus = 'active' | 'canceled' | 'incomplete' | 'incomplete_expired' | 'past_due' | 'trialing' | 'unpaid';
+/**
+ * Subscription represents a customer subscription
+ */
+interface Subscription {
+    id: string;
+    customer_id: string;
+    price_id: string;
+    status: SubscriptionStatus;
+    current_period_start: string;
+    current_period_end: string;
+    cancel_at_period_end: boolean;
+    trial_start?: string;
+    trial_end?: string;
+    canceled_at?: string;
+    metadata?: Record<string, string>;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Input for creating a subscription
+ */
+interface CreateSubscriptionInput {
+    customer_id: string;
+    price_id: string;
+    trial_days?: number;
+    metadata?: Record<string, string>;
+}
+/**
+ * Input for updating a subscription
+ */
+interface UpdateSubscriptionInput {
+    price_id?: string;
+    cancel_at_period_end?: boolean;
+    metadata?: Record<string, string>;
+}
+/**
+ * Price preview for subscription changes
+ */
+interface SubscriptionPreview {
+    proration_amount: number;
+    next_invoice_amount: number;
+    next_invoice_date: string;
+}
+/**
+ * Entitlement represents a feature access grant
+ */
+interface Entitlement {
+    feature_key: string;
+    has_access: boolean;
+    limit?: number;
+    usage?: number;
+    metadata?: Record<string, string>;
+}
+/**
+ * Input for checking entitlements
+ */
+interface CheckEntitlementInput {
+    customer_id: string;
+    feature_key: string;
+}
+/**
+ * Usage event for tracking
+ */
+interface UsageEvent {
+    customer_id?: string;
+    feature_key: string;
+    quantity: number;
+    timestamp?: string;
+    idempotency_key?: string;
+    metadata?: Record<string, string>;
+}
+/**
+ * Usage metrics response
+ */
+interface UsageMetrics {
+    feature_key: string;
+    current_usage: number;
+    limit?: number;
+    period_start: string;
+    period_end: string;
+}
+/**
+ * Invoice represents a billing invoice
+ */
+interface Invoice {
+    id: string;
+    customer_id: string;
+    amount_due: number;
+    amount_paid: number;
+    currency: string;
+    status: 'draft' | 'open' | 'paid' | 'uncollectible' | 'void';
+    due_date?: string;
+    paid_at?: string;
+    invoice_pdf?: string;
+    created_at: string;
+}
+/**
+ * Payment method
+ */
+interface PaymentMethod {
+    id: string;
+    type: 'card' | 'bank_account';
+    card?: {
+        brand: string;
+        last4: string;
+        exp_month: number;
+        exp_year: number;
+    };
+    is_default: boolean;
+    created_at: string;
+}
+/**
+ * Pagination metadata
+ */
+interface PaginationMeta {
+    total: number;
+    page: number;
+    page_size: number;
+    total_pages: number;
+}
+/**
+ * Paginated response wrapper
+ */
+interface PaginatedResponse<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+/**
+ * API error response
+ */
+interface APIErrorResponse {
+    error: {
+        message: string;
+        code?: string;
+        details?: unknown;
+    };
+}
+/**
+ * Feature type for portal
+ */
+type PortalFeatureType = 'boolean_flag' | 'usage_quota' | 'numeric_limit';
+/**
+ * Usage information for a feature
+ */
+interface PortalUsageInfo {
+    consumed: number;
+    limit: number;
+    percentage: number;
+    resetDate?: string;
+}
+/**
+ * Feature with usage tracking for portal
+ */
+interface PortalFeatureWithUsage {
+    id: string;
+    name: string;
+    title: string;
+    type: PortalFeatureType;
+    properties: Record<string, unknown>;
+    usage?: PortalUsageInfo;
+    enabled?: boolean;
+}
+/**
+ * Product information for portal
+ */
+interface PortalProduct {
+    id: string;
+    name: string;
+    description?: string;
+}
+/**
+ * Price information for portal
+ */
+interface PortalPrice {
+    id: string;
+    amount: number;
+    currency: string;
+    interval: 'day' | 'week' | 'month' | 'year';
+    intervalCount: number;
+}
+/**
+ * Subscription details for portal
+ */
+interface PortalSubscription {
+    id: string;
+    status: 'active' | 'trialing' | 'past_due' | 'canceled' | 'unpaid';
+    product: PortalProduct;
+    price: PortalPrice;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+    trialEnd: string | null;
+    canceledAt: string | null;
+    features: PortalFeatureWithUsage[];
+}
+/**
+ * Line item in an invoice
+ */
+interface PortalLineItem {
+    description: string;
+    quantity: number;
+    amount: number;
+}
+/**
+ * Invoice details for portal
+ */
+interface PortalInvoice {
+    id: string;
+    number: string;
+    date: string;
+    dueDate: string;
+    status: 'paid' | 'open' | 'failed' | 'void';
+    amount: number;
+    currency: string;
+    pdfUrl: string | null;
+    lineItems: PortalLineItem[];
+    failureReason?: string;
+}
+/**
+ * Card details for portal
+ */
+interface PortalCardDetails {
+    brand: 'visa' | 'mastercard' | 'amex' | 'discover' | 'diners' | 'jcb' | 'unionpay';
+    last4: string;
+    expMonth: number;
+    expYear: number;
+}
+/**
+ * Payment method for portal
+ */
+interface PortalPaymentMethod {
+    id: string;
+    type: 'card' | 'bank_account';
+    card?: PortalCardDetails;
+    isDefault: boolean;
+}
+/**
+ * Billing address
+ */
+interface PortalAddress {
+    line1: string;
+    line2?: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    country: string;
+}
+/**
+ * Customer details for portal
+ */
+interface PortalCustomer {
+    id: string;
+    email: string;
+    name: string;
+    billingAddress?: PortalAddress;
+}
+/**
+ * Available plan for upgrade/downgrade
+ */
+interface PortalAvailablePlan {
+    id: string;
+    name: string;
+    price: {
+        amount: number;
+        currency: string;
+        interval: 'day' | 'week' | 'month' | 'year';
+    };
+    type: 'upgrade' | 'downgrade' | 'current';
+}
+/**
+ * Complete portal data from API
+ */
+interface CustomerPortalData {
+    subscription: PortalSubscription | null;
+    invoices: PortalInvoice[];
+    paymentMethods: PortalPaymentMethod[];
+    customer: PortalCustomer;
+    availablePlans: PortalAvailablePlan[];
+}
+/**
+ * Input for updating subscription via portal
+ */
+interface PortalUpdateSubscriptionInput {
+    newPriceId: string;
+    prorationBehavior?: 'always_invoice' | 'create_prorations' | 'none';
+}
+/**
+ * Response for subscription update
+ */
+interface PortalUpdateSubscriptionResponse {
+    subscription: {
+        id: string;
+        status: string;
+        proration?: {
+            credited: number;
+            charged: number;
+            total: number;
+        };
+    };
+    upcomingInvoice?: {
+        amountDue: number;
+        dueDate: string;
+    };
+}
+/**
+ * Input for canceling subscription via portal
+ */
+interface PortalCancelSubscriptionInput {
+    cancelAtPeriodEnd: boolean;
+    cancellationReason?: 'too_expensive' | 'missing_features' | 'found_alternative' | 'no_longer_needed' | 'other';
+    feedback?: string;
+}
+/**
+ * Response for subscription cancellation
+ */
+interface PortalCancelSubscriptionResponse {
+    subscription: {
+        id: string;
+        status: string;
+        cancelAtPeriodEnd: boolean;
+        canceledAt: string;
+        currentPeriodEnd: string;
+    };
+    message: string;
+}
+/**
+ * Input for adding a payment method
+ */
+interface AddPaymentMethodInput {
+    paymentMethodId: string;
+    setAsDefault?: boolean;
+}
+/**
+ * Response for adding a payment method
+ */
+interface AddPaymentMethodResponse {
+    paymentMethod: PortalPaymentMethod;
+}
+/**
+ * Setup intent response for adding cards
+ */
+interface SetupIntentResponse {
+    clientSecret: string;
+    stripePublishableKey: string;
+}
+/**
+ * Response for retrying an invoice
+ */
+interface RetryInvoiceResponse {
+    success: boolean;
+    invoice: {
+        id: string;
+        status: 'paid' | 'open' | 'failed' | 'void';
+        amount: number;
+    };
+}
+/**
+ * Input for updating customer billing
+ */
+interface UpdateCustomerBillingInput {
+    name?: string;
+    email?: string;
+    billingAddress?: PortalAddress;
+}
+/**
+ * Customer billing info response
+ */
+interface CustomerBillingInfo {
+    id: string;
+    email: string;
+    name: string;
+    billingAddress?: PortalAddress;
+}
+/**
+ * Proration details for subscription changes
+ */
+interface CheckoutProration {
+    credited: number;
+    charged: number;
+    total: number;
+    explanation: string;
+}
+/**
+ * Product summary for checkout
+ */
+interface CheckoutProduct {
+    name: string;
+    interval: 'day' | 'week' | 'month' | 'year';
+    features: string[];
+}
+/**
+ * Customer info for checkout
+ */
+interface CheckoutCustomer {
+    email: string;
+    name: string;
+}
+/**
+ * Checkout session returned by the API
+ */
+interface CheckoutSession {
+    id: string;
+    clientSecret: string;
+    amount: number;
+    currency: string;
+    proration?: CheckoutProration;
+    product: CheckoutProduct;
+    customer: CheckoutCustomer;
+    stripeAccountId?: string;
+}
+/**
+ * Input for creating a checkout session
+ */
+interface CreateCheckoutInput {
+    priceId: string;
+    customerEmail?: string;
+    customerName?: string;
+    existingSubscriptionId?: string;
+}
+/**
+ * Response from creating a checkout session
+ * The API returns the checkout session directly
+ */
+type CreateCheckoutResponse = CheckoutSession;
+/**
+ * Input for confirming a checkout
+ */
+interface ConfirmCheckoutInput {
+    paymentMethodId: string;
+}
+/**
+ * Response from confirming a checkout
+ */
+interface ConfirmCheckoutResponse {
+    success: boolean;
+    subscriptionId: string;
+    status: 'active' | 'trialing';
+    message: string;
+}
+/**
+ * Input for creating an iframe checkout session
+ */
+interface CreateCheckoutSessionInput {
+    priceId: string;
+    customer?: {
+        email?: string;
+        name?: string;
+        taxId?: string;
+    };
+    couponCode?: string;
+    metadata?: Record<string, string>;
+    existingSubscriptionId?: string;
+    mode?: 'embedded' | 'redirect';
+    successUrl?: string;
+    cancelUrl?: string;
+}
+/**
+ * Response from creating a checkout session
+ */
+interface CreateCheckoutSessionResponse {
+    id: string;
+    url?: string;
+    expiresAt: string;
+    status: 'pending' | 'completed' | 'expired';
+}
+/**
+ * Detailed checkout session information
+ */
+interface CheckoutSessionDetails {
+    id: string;
+    clientSecret: string;
+    amount: number;
+    currency: string;
+    priceId: string;
+    product: CheckoutProduct;
+    customer: CheckoutCustomer;
+    couponCode?: string;
+    discountAmount?: number;
+    taxAmount?: number;
+    totalAmount: number;
+    proration?: CheckoutProration;
+    status: 'pending' | 'processing' | 'completed' | 'failed' | 'expired';
+    expiresAt: string;
+    stripeAccountId?: string;
+}
+/**
+ * Feature properties for pricing table
+ */
+interface PricingFeatureProperties {
+    limit?: number;
+    period?: 'month' | 'year';
+    unit?: string;
+}
+/**
+ * Feature in pricing table
+ */
+interface PricingFeature {
+    id: string;
+    name: string;
+    title: string;
+    type: 'boolean_flag' | 'usage_quota' | 'numeric_limit';
+    properties: PricingFeatureProperties;
+}
+/**
+ * Price for a product
+ */
+interface PricingPrice {
+    id: string;
+    amount: number;
+    currency: string;
+    interval: 'month' | 'year' | 'week' | 'day';
+    intervalCount: number;
+}
+/**
+ * Product in pricing table
+ */
+interface PricingProduct {
+    id: string;
+    name: string;
+    description: string;
+    prices: PricingPrice[];
+    features: PricingFeature[];
+    isCurrentPlan: boolean;
+    trialDays: number;
+    highlighted?: boolean;
+}
+/**
+ * Current subscription info for pricing table
+ */
+interface PricingCurrentSubscription {
+    id: string;
+    productId: string;
+    priceId: string;
+    status: 'active' | 'trialing' | 'past_due' | 'canceled';
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+}
+/**
+ * Response from GET /sdk/products
+ */
+interface GetProductsResponse {
+    products: PricingProduct[];
+    currentSubscription: PricingCurrentSubscription | null;
+}
+/**
+ * Type of nudge trigger
+ */
+type NudgeTriggerType = 'usage_threshold' | 'feature_access' | 'time_based' | 'custom';
+/**
+ * Message content for nudge
+ */
+interface NudgeMessage {
+    title: string;
+    body: string;
+    cta: string;
+}
+/**
+ * Suggested plan for upgrade
+ */
+interface SuggestedPlan {
+    id: string;
+    priceId: string;
+    name: string;
+    price: {
+        amount: number;
+        currency: string;
+        interval: string;
+    };
+    highlights: string[];
+}
+/**
+ * Nudge trigger data
+ */
+interface NudgeTrigger {
+    type: NudgeTriggerType;
+    feature?: string;
+    threshold?: number;
+    actual?: number;
+    message: NudgeMessage;
+    suggestedPlan: SuggestedPlan;
+}
+/**
+ * Response from GET /sdk/usage/check
+ */
+interface UsageCheckResponse {
+    shouldShowNudge: boolean;
+    trigger?: NudgeTrigger;
+}
+/**
+ * Effective timing for plan changes
+ */
+type ChangeEffectiveTiming = 'immediate' | 'period_end';
+/**
+ * Type of plan change
+ */
+type ChangeType = 'upgrade' | 'downgrade';
+/**
+ * Plan information
+ */
+interface PlanInfo {
+    product_id: string;
+    product_name: string;
+    price_id: string;
+    amount: number;
+    currency: string;
+    interval: string;
+}
+/**
+ * Proration details
+ */
+interface ProrationInfo {
+    unused_time_credit: number;
+    new_plan_charge: number;
+    immediate_payment: number;
+    credit_applied: number;
+    breakdown: string;
+}
+/**
+ * Input for previewing a plan change
+ */
+interface PreviewChangeInput {
+    new_price_id: string;
+    effective_date?: ChangeEffectiveTiming;
+}
+/**
+ * Response from POST /subscriptions/:id/preview-change
+ */
+interface PreviewChangeResponse {
+    current_plan: PlanInfo;
+    new_plan: PlanInfo;
+    proration: ProrationInfo;
+    change_type: ChangeType;
+    effective_date: string;
+    next_billing_date: string;
+    notes: string[];
+}
+/**
+ * Input for changing a plan
+ */
+interface ChangePlanInput {
+    new_price_id: string;
+    confirm_amount?: number;
+    effective_date?: ChangeEffectiveTiming;
+}
+/**
+ * Response from POST /subscriptions/:id/change-plan
+ */
+interface ChangePlanResponse {
+    subscription: {
+        id: string;
+        status: string;
+        price_id: string;
+        current_period_end: string;
+    };
+    change: {
+        id: string;
+        from_price_id: string;
+        to_price_id: string;
+        change_type: ChangeType;
+        status: string;
+        effective_date: string;
+    };
+    invoice?: {
+        id: string;
+        amount_due: number;
+        status: string;
+    };
+    message: string;
+}
+/**
+ * Available plan option
+ */
+interface AvailablePlan {
+    product_id: string;
+    product_name: string;
+    description: string | null;
+    price_id: string;
+    amount: number;
+    currency: string;
+    interval: string;
+    is_free: boolean;
+}
+/**
+ * Response from GET /subscriptions/:id/available-plans
+ */
+interface AvailablePlansResponse {
+    current_plan: {
+        product_id: string;
+        product_name: string;
+        price_id: string;
+        amount: number;
+        currency: string;
+        interval: string;
+    } | null;
+    available_upgrades: AvailablePlan[];
+    available_downgrades: AvailablePlan[];
+    restrictions: string[];
+}
+
+/**
+ * Base error class for all BillingOS SDK errors
+ */
+declare class BillingOSError extends Error {
+    status?: number | undefined;
+    data?: unknown | undefined;
+    constructor(message: string, status?: number | undefined, data?: unknown | undefined);
+}
+/**
+ * Thrown when the API request fails due to authentication issues (401)
+ */
+declare class UnauthorizedError extends BillingOSError {
+    constructor(message?: string, data?: unknown);
+}
+/**
+ * Thrown when the requested resource is not found (404)
+ */
+declare class NotFoundError extends BillingOSError {
+    constructor(message?: string, data?: unknown);
+}
+/**
+ * Thrown when the request fails validation (400)
+ */
+declare class ValidationError extends BillingOSError {
+    constructor(message?: string, data?: unknown);
+}
+/**
+ * Thrown when rate limit is exceeded (429)
+ */
+declare class RateLimitError extends BillingOSError {
+    constructor(message?: string, data?: unknown);
+}
+/**
+ * Thrown when the server returns a 500 error
+ */
+declare class ServerError extends BillingOSError {
+    constructor(message?: string, data?: unknown);
+}
+/**
+ * Thrown when the network request fails
+ */
+declare class NetworkError extends BillingOSError {
+    constructor(message?: string, originalError?: unknown);
+}
+/**
+ * Type guard to check if an error is a validation error
+ */
+declare function isValidationError(error: unknown): error is ValidationError;
+/**
+ * Type guard to check if an error is an unauthorized error
+ */
+declare function isUnauthorizedError(error: unknown): error is UnauthorizedError;
+/**
+ * Type guard to check if an error is a not found error
+ */
+declare function isNotFoundError(error: unknown): error is NotFoundError;
+/**
+ * Type guard to check if an error is a rate limit error
+ */
+declare function isRateLimitError(error: unknown): error is RateLimitError;
+
+/**
+ * Configuration options for the BillingOS client
+ */
+interface BillingOSClientOptions {
+    /**
+     * Base URL for the API (defaults to production)
+     */
+    baseUrl?: string;
+    /**
+     * Environment (production or sandbox)
+     */
+    environment?: 'production' | 'sandbox';
+    /**
+     * API version to use
+     */
+    version?: string;
+    /**
+     * Custom headers to include in all requests
+     */
+    headers?: Record<string, string>;
+    /**
+     * Timeout for requests in milliseconds
+     */
+    timeout?: number;
+}
+/**
+ * Main BillingOS API client
+ */
+declare class BillingOSClient {
+    private sessionToken;
+    private baseUrl;
+    private headers;
+    private timeout;
+    constructor(sessionToken: string, options?: BillingOSClientOptions);
+    /**
+     * Internal method to make HTTP requests
+     */
+    private request;
+    /**
+     * GET request helper
+     */
+    get<T>(path: string): Promise<T>;
+    /**
+     * POST request helper
+     */
+    post<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * PATCH request helper
+     */
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * DELETE request helper
+     */
+    delete<T>(path: string): Promise<T>;
+    /**
+     * Create a new customer
+     */
+    createCustomer(input: CreateCustomerInput): Promise<Customer>;
+    /**
+     * Get a customer by ID
+     */
+    getCustomer(id: string): Promise<Customer>;
+    /**
+     * List customers (paginated)
+     */
+    listCustomers(params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedResponse<Customer>>;
+    /**
+     * Update a customer
+     */
+    updateCustomer(id: string, input: UpdateCustomerInput): Promise<Customer>;
+    /**
+     * Delete a customer
+     */
+    deleteCustomer(id: string): Promise<void>;
+    /**
+     * Create a new subscription
+     */
+    createSubscription(input: CreateSubscriptionInput): Promise<Subscription>;
+    /**
+     * Get a subscription by ID
+     */
+    getSubscription(id: string): Promise<Subscription>;
+    /**
+     * List subscriptions (paginated)
+     */
+    listSubscriptions(params?: {
+        customer_id?: string;
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedResponse<Subscription>>;
+    /**
+     * Update a subscription
+     */
+    updateSubscription(id: string, input: UpdateSubscriptionInput): Promise<Subscription>;
+    /**
+     * Cancel a subscription
+     */
+    cancelSubscription(id: string, immediately?: boolean): Promise<Subscription>;
+    /**
+     * Reactivate a canceled subscription
+     */
+    reactivateSubscription(id: string): Promise<Subscription>;
+    /**
+     * Preview subscription changes
+     */
+    previewSubscription(id: string, input: UpdateSubscriptionInput): Promise<SubscriptionPreview>;
+    /**
+     * Get available plans for upgrade/downgrade
+     */
+    getAvailablePlans(subscriptionId: string): Promise<AvailablePlansResponse>;
+    /**
+     * Preview a plan change (upgrade/downgrade) with proration details
+     */
+    previewPlanChange(subscriptionId: string, input: PreviewChangeInput): Promise<PreviewChangeResponse>;
+    /**
+     * Execute a plan change (upgrade/downgrade)
+     */
+    changePlan(subscriptionId: string, input: ChangePlanInput): Promise<ChangePlanResponse>;
+    /**
+     * Check if a customer has access to a feature
+     * Customer ID is resolved server-side from session token
+     */
+    checkEntitlement(input: CheckEntitlementInput): Promise<Entitlement>;
+    /**
+     * List all entitlements for a customer
+     * Customer ID is resolved server-side from session token
+     */
+    listEntitlements(_customerId?: string): Promise<Entitlement[]>;
+    /**
+     * Track a usage event
+     * Customer ID is resolved server-side from session token
+     */
+    trackUsage(event: UsageEvent): Promise<void>;
+    /**
+     * Get usage metrics for a customer and feature
+     * Customer ID is resolved server-side from session token
+     */
+    getUsageMetrics(_customerId?: string, featureKey?: string): Promise<UsageMetrics>;
+    /**
+     * Get an invoice by ID
+     */
+    getInvoice(id: string): Promise<Invoice>;
+    /**
+     * List invoices for a customer
+     */
+    listInvoices(params?: {
+        customer_id?: string;
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedResponse<Invoice>>;
+    /**
+     * List payment methods for a customer
+     */
+    listPaymentMethods(customerId: string): Promise<PaymentMethod[]>;
+    /**
+     * Remove a payment method
+     */
+    removePaymentMethod(id: string): Promise<void>;
+    /**
+     * Set default payment method
+     */
+    setDefaultPaymentMethod(id: string): Promise<void>;
+    /**
+     * Get all portal data for the current customer
+     */
+    getCustomerPortal(): Promise<CustomerPortalData>;
+    /**
+     * Update subscription (upgrade/downgrade)
+     */
+    updatePortalSubscription(subscriptionId: string, input: PortalUpdateSubscriptionInput): Promise<PortalUpdateSubscriptionResponse>;
+    /**
+     * Cancel subscription with feedback
+     */
+    cancelPortalSubscription(subscriptionId: string, input: PortalCancelSubscriptionInput): Promise<PortalCancelSubscriptionResponse>;
+    /**
+     * Reactivate a canceled subscription
+     */
+    reactivatePortalSubscription(subscriptionId: string): Promise<void>;
+    /**
+     * Add a payment method
+     */
+    addPaymentMethod(input: AddPaymentMethodInput): Promise<AddPaymentMethodResponse>;
+    /**
+     * Get setup intent for adding a new card
+     */
+    getSetupIntent(): Promise<SetupIntentResponse>;
+    /**
+     * Retry a failed invoice
+     */
+    retryInvoice(invoiceId: string, paymentMethodId?: string): Promise<RetryInvoiceResponse>;
+    /**
+     * Update customer billing information
+     */
+    updateCustomerBilling(input: UpdateCustomerBillingInput): Promise<CustomerBillingInfo>;
+    /**
+     * Create a checkout session for purchasing a subscription
+     */
+    createCheckout(input: CreateCheckoutInput): Promise<CreateCheckoutResponse>;
+    /**
+     * Confirm a checkout after payment is processed
+     */
+    confirmCheckout(clientSecret: string, paymentMethodId: string): Promise<ConfirmCheckoutResponse>;
+    /**
+     * Checkout API methods for iframe-based checkout modal
+     */
+    checkout: {
+        /**
+         * Create a checkout session for iframe-based checkout
+         */
+        createSession: (input: CreateCheckoutSessionInput) => Promise<CreateCheckoutSessionResponse>;
+        /**
+         * Get checkout session details
+         */
+        getSession: (sessionId: string) => Promise<CheckoutSessionDetails>;
+        /**
+         * Cancel a checkout session (not implemented in backend yet)
+         */
+        cancelSession: (_sessionId: string) => Promise<void>;
+        /**
+         * Confirm payment for a checkout session
+         */
+        confirmPayment: (clientSecret: string, paymentMethodId: string) => Promise<ConfirmCheckoutResponse>;
+        /**
+         * Apply coupon to a checkout session (not implemented in backend yet)
+         */
+        applyCoupon: (_sessionId: string, _couponCode: string) => Promise<CheckoutSessionDetails>;
+    };
+    /**
+     * Portal API methods for iframe-based customer portal
+     */
+    portal: {
+        /**
+         * Create a portal session for customer self-service
+         */
+        createSession: (input?: {
+            customerId?: string;
+            metadata?: Record<string, any>;
+        }) => Promise<{
+            id: string;
+            expiresAt: string;
+        }>;
+        /**
+         * Get portal session status
+         */
+        getSessionStatus: (sessionId: string) => Promise<{
+            isValid: boolean;
+            expiresAt?: string;
+        }>;
+        /**
+         * Get portal data for a session
+         */
+        getPortalData: (sessionId: string) => Promise<any>;
+    };
+    /**
+     * Get all products for the pricing table
+     * @param planIds - Optional array of plan IDs to filter
+     */
+    getProducts(planIds?: string[]): Promise<GetProductsResponse>;
+    /**
+     * Check usage and get nudge trigger if applicable
+     * Uses usage-metrics endpoint and computes nudge client-side
+     */
+    checkUsage(): Promise<UsageCheckResponse>;
+}
+/**
+ * Factory function to create a BillingOS client instance
+ */
+declare function createBillingOSClient(sessionToken: string, options?: BillingOSClientOptions): BillingOSClient;
+
+/**
+ * Options for opening the checkout modal programmatically
+ */
+interface CheckoutOpenOptions {
+    /**
+     * The price ID to checkout
+     */
+    priceId: string;
+    /**
+     * Customer information to pre-populate
+     */
+    customer?: {
+        email?: string;
+        name?: string;
+        taxId?: string;
+    };
+    /**
+     * Coupon code to apply
+     */
+    couponCode?: string;
+    /**
+     * Whether to collect billing address
+     */
+    collectBillingAddress?: boolean;
+    /**
+     * Currency for the checkout (defaults to price currency)
+     */
+    currency?: string;
+    /**
+     * Existing subscription ID for upgrades/downgrades
+     */
+    existingSubscriptionId?: string;
+    /**
+     * Custom metadata to attach to the subscription
+     */
+    metadata?: Record<string, string>;
+    /**
+     * Theme for the checkout modal
+     */
+    theme?: 'light' | 'dark' | 'auto';
+    /**
+     * Locale for the checkout (e.g., 'en', 'es', 'fr')
+     */
+    locale?: string;
+    /**
+     * Success callback with the created subscription
+     */
+    onSuccess?: (subscription: Subscription) => void;
+    /**
+     * Error callback
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Cancel callback when user closes without completing
+     */
+    onCancel?: () => void;
+    /**
+     * Debug mode for development
+     */
+    debug?: boolean;
+    /**
+     * Session token for authentication (if not using provider)
+     */
+    sessionToken?: string;
+    /**
+     * API base URL (if not using provider)
+     */
+    apiUrl?: string;
+}
+/**
+ * Programmatic checkout API
+ */
+declare class CheckoutAPI {
+    private client?;
+    private container?;
+    private root?;
+    constructor(client?: BillingOSClient);
+    /**
+     * Open the checkout modal programmatically
+     */
+    open(options: CheckoutOpenOptions): Promise<{
+        success: boolean;
+        subscription?: Subscription;
+        error?: Error;
+    }>;
+    /**
+     * Close the checkout modal
+     */
+    close(): void;
+}
+/**
+ * Get or create the global checkout API instance
+ */
+declare function getCheckoutAPI(client?: BillingOSClient): CheckoutAPI;
+/**
+ * Convenience function to open checkout modal
+ */
+declare function openCheckout(options: CheckoutOpenOptions): Promise<{
+    success: boolean;
+    subscription?: Subscription;
+    error?: Error;
+}>;
+
+interface SessionTokenData {
+    sessionToken: string;
+    expiresAt: string;
+}
+interface UseSessionTokenOptions {
+    /** URL to fetch session token from (e.g., /api/billingos-session) */
+    tokenUrl?: string;
+    /** Manually provided session token */
+    token?: string;
+    /** How many seconds before expiry to refresh (default: 300 = 5 minutes) */
+    refreshBeforeExpiry?: number;
+    /** Enable auto-refresh (default: true) */
+    autoRefresh?: boolean;
+    /** Callback when token is refreshed */
+    onTokenRefresh?: (token: string) => void;
+    /** Callback when token fetch fails */
+    onError?: (error: Error) => void;
+}
+interface UseSessionTokenReturn {
+    /** Current session token */
+    token: string | null;
+    /** When the token expires */
+    expiresAt: Date | null;
+    /** Whether the token is currently being fetched */
+    isLoading: boolean;
+    /** Any error that occurred */
+    error: Error | null;
+    /** Manually refresh the token */
+    refresh: () => Promise<void>;
+    /** Whether the token is valid (not expired) */
+    isValid: boolean;
+}
+/**
+ * Hook to manage session tokens with automatic fetching and refreshing
+ *
+ * @example
+ * // Auto-fetch from endpoint
+ * const { token, isLoading } = useSessionToken({
+ *   tokenUrl: '/api/billingos-session',
+ * });
+ *
+ * @example
+ * // Manual token
+ * const { token } = useSessionToken({
+ *   token: 'bos_session_abc123...',
+ * });
+ */
+declare function useSessionToken(options?: UseSessionTokenOptions): UseSessionTokenReturn;
+
+/**
+ * Query keys for subscription-related queries
+ */
+declare const subscriptionKeys: {
+    all: readonly ["subscriptions"];
+    lists: () => readonly ["subscriptions", "list"];
+    list: (filters?: Record<string, unknown>) => readonly ["subscriptions", "list", Record<string, unknown> | undefined];
+    details: () => readonly ["subscriptions", "detail"];
+    detail: (id: string) => readonly ["subscriptions", "detail", string];
+    preview: (id: string, input: UpdateSubscriptionInput) => readonly ["subscriptions", "preview", string, UpdateSubscriptionInput];
+};
+/**
+ * Fetch a single subscription by ID
+ *
+ * @param id - Subscription ID
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * function SubscriptionDetails({ id }: { id: string }) {
+ *   const { data: subscription, isLoading, error } = useSubscription(id)
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   if (error) return <div>Error: {error.message}</div>
+ *
+ *   return (
+ *     <div>
+ *       <h1>Subscription Status: {subscription.status}</h1>
+ *       <p>Next billing: {subscription.current_period_end}</p>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useSubscription(id: string, options?: Omit<UseQueryOptions<Subscription>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<Subscription, Error>;
+/**
+ * Fetch a list of subscriptions (paginated)
+ *
+ * @param params - Query parameters (customer_id, pagination)
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * function SubscriptionsList() {
+ *   const { data, isLoading } = useSubscriptions({
+ *     customer_id: 'cus_123',
+ *     page: 1,
+ *     page_size: 10
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *
+ *   return (
+ *     <div>
+ *       {data?.data.map(subscription => (
+ *         <SubscriptionCard key={subscription.id} subscription={subscription} />
+ *       ))}
+ *       <p>Total: {data?.meta.total}</p>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useSubscriptions(params?: {
+    customer_id?: string;
+    page?: number;
+    page_size?: number;
+}, options?: Omit<UseQueryOptions<PaginatedResponse<Subscription>>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<PaginatedResponse<Subscription>, Error>;
+/**
+ * Create a new subscription
+ *
+ * @param options - React Query mutation options
+ *
+ * @example
+ * ```tsx
+ * function CreateSubscriptionButton() {
+ *   const createSubscription = useCreateSubscription({
+ *     onSuccess: (subscription) => {
+ *       console.log('Subscription created:', subscription.id)
+ *       // Redirect to success page
+ *     },
+ *     onError: (error) => {
+ *       console.error('Failed to create subscription:', error)
+ *     }
+ *   })
+ *
+ *   const handleClick = () => {
+ *     createSubscription.mutate({
+ *       customer_id: 'cus_123',
+ *       price_id: 'price_456',
+ *       trial_days: 14
+ *     })
+ *   }
+ *
+ *   return (
+ *     <button
+ *       onClick={handleClick}
+ *       disabled={createSubscription.isPending}
+ *     >
+ *       {createSubscription.isPending ? 'Creating...' : 'Subscribe'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useCreateSubscription(options?: Omit<UseMutationOptions<Subscription, Error, CreateSubscriptionInput>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<Subscription, Error, CreateSubscriptionInput, unknown>;
+/**
+ * Update an existing subscription
+ *
+ * @param subscriptionId - Subscription ID to update
+ * @param options - React Query mutation options
+ *
+ * @example
+ * ```tsx
+ * function UpgradeButton({ subscriptionId }: { subscriptionId: string }) {
+ *   const updateSubscription = useUpdateSubscription(subscriptionId, {
+ *     onSuccess: () => {
+ *       console.log('Subscription updated!')
+ *     }
+ *   })
+ *
+ *   const handleUpgrade = () => {
+ *     updateSubscription.mutate({
+ *       price_id: 'price_pro_plan'
+ *     })
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleUpgrade} disabled={updateSubscription.isPending}>
+ *       Upgrade to Pro
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useUpdateSubscription(subscriptionId: string, options?: Omit<UseMutationOptions<Subscription, Error, UpdateSubscriptionInput>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<Subscription, Error, UpdateSubscriptionInput, unknown>;
+/**
+ * Cancel a subscription
+ *
+ * @param subscriptionId - Subscription ID to cancel
+ * @param options - React Query mutation options
+ *
+ * @example
+ * ```tsx
+ * function CancelButton({ subscriptionId }: { subscriptionId: string }) {
+ *   const cancelSubscription = useCancelSubscription(subscriptionId, {
+ *     onSuccess: () => {
+ *       alert('Subscription cancelled')
+ *     }
+ *   })
+ *
+ *   const handleCancel = (immediately: boolean) => {
+ *     if (confirm('Are you sure you want to cancel?')) {
+ *       cancelSubscription.mutate({ immediately })
+ *     }
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => handleCancel(false)}>
+ *         Cancel at period end
+ *       </button>
+ *       <button onClick={() => handleCancel(true)}>
+ *         Cancel immediately
+ *       </button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useCancelSubscription(subscriptionId: string, options?: Omit<UseMutationOptions<Subscription, Error, {
+    immediately?: boolean;
+}>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<Subscription, Error, {
+    immediately?: boolean;
+}, unknown>;
+/**
+ * Reactivate a canceled subscription
+ *
+ * @param subscriptionId - Subscription ID to reactivate
+ * @param options - React Query mutation options
+ *
+ * @example
+ * ```tsx
+ * function ReactivateButton({ subscriptionId }: { subscriptionId: string }) {
+ *   const reactivateSubscription = useReactivateSubscription(subscriptionId)
+ *
+ *   return (
+ *     <button
+ *       onClick={() => reactivateSubscription.mutate()}
+ *       disabled={reactivateSubscription.isPending}
+ *     >
+ *       Reactivate Subscription
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useReactivateSubscription(subscriptionId: string, options?: Omit<UseMutationOptions<Subscription, Error, void>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<Subscription, Error, void, unknown>;
+/**
+ * Preview subscription changes before applying them
+ *
+ * @param subscriptionId - Subscription ID
+ * @param input - Proposed changes
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * function UpgradePreview({ subscriptionId }: { subscriptionId: string }) {
+ *   const { data: preview, isLoading } = useSubscriptionPreview(
+ *     subscriptionId,
+ *     { price_id: 'price_pro_plan' }
+ *   )
+ *
+ *   if (isLoading) return <div>Calculating...</div>
+ *
+ *   return (
+ *     <div>
+ *       <p>Proration: ${preview?.proration_amount / 100}</p>
+ *       <p>Next invoice: ${preview?.next_invoice_amount / 100}</p>
+ *       <p>Billing date: {preview?.next_invoice_date}</p>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useSubscriptionPreview(subscriptionId: string, input: UpdateSubscriptionInput, options?: Omit<UseQueryOptions<SubscriptionPreview>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<SubscriptionPreview, Error>;
+/**
+ * Fetch available plans for upgrade/downgrade
+ *
+ * @param subscriptionId - Subscription ID
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * function AvailablePlans({ subscriptionId }: { subscriptionId: string }) {
+ *   const { data, isLoading } = useAvailablePlans(subscriptionId)
+ *
+ *   if (isLoading) return <div>Loading plans...</div>
+ *
+ *   return (
+ *     <div>
+ *       <h3>Upgrades:</h3>
+ *       {data?.available_upgrades.map(plan => (
+ *         <div key={plan.price_id}>{plan.product_name}</div>
+ *       ))}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useAvailablePlans(subscriptionId: string, options?: Omit<UseQueryOptions<AvailablePlansResponse>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<AvailablePlansResponse, Error>;
+/**
+ * Preview a plan change with proration details
+ *
+ * @param options - React Query mutation options
+ *
+ * @example
+ * ```tsx
+ * function PlanChangePreview({ subscriptionId }: { subscriptionId: string }) {
+ *   const previewChange = usePreviewPlanChange()
+ *
+ *   const handlePreview = async (newPriceId: string) => {
+ *     const preview = await previewChange.mutateAsync({
+ *       subscriptionId,
+ *       input: { new_price_id: newPriceId }
+ *     })
+ *     console.log('Proration:', preview.proration.immediate_payment)
+ *   }
+ *
+ *   return <button onClick={() => handlePreview('price_123')}>Preview</button>
+ * }
+ * ```
+ */
+declare function usePreviewPlanChange(options?: Omit<UseMutationOptions<PreviewChangeResponse, Error, {
+    subscriptionId: string;
+    input: PreviewChangeInput;
+}>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<PreviewChangeResponse, Error, {
+    subscriptionId: string;
+    input: PreviewChangeInput;
+}, unknown>;
+/**
+ * Execute a plan change (upgrade/downgrade)
+ *
+ * @param options - React Query mutation options
+ *
+ * @example
+ * ```tsx
+ * function ChangePlanButton({ subscriptionId }: { subscriptionId: string }) {
+ *   const changePlan = useChangePlan({
+ *     onSuccess: (response) => {
+ *       console.log('Plan changed:', response.subscription.id)
+ *     }
+ *   })
+ *
+ *   const handleChange = () => {
+ *     changePlan.mutate({
+ *       subscriptionId,
+ *       input: {
+ *         new_price_id: 'price_456',
+ *         confirm_amount: 1999
+ *       }
+ *     })
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleChange} disabled={changePlan.isPending}>
+ *       {changePlan.isPending ? 'Changing...' : 'Change Plan'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useChangePlan(options?: Omit<UseMutationOptions<ChangePlanResponse, Error, {
+    subscriptionId: string;
+    input: ChangePlanInput;
+}>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<ChangePlanResponse, Error, {
+    subscriptionId: string;
+    input: ChangePlanInput;
+}, unknown>;
+
+/**
+ * Result from opening checkout
+ */
+interface CheckoutResult {
+    success: boolean;
+    subscription?: Subscription;
+    error?: Error;
+}
+/**
+ * Hook for programmatically opening checkout
+ */
+declare function useCheckout(): {
+    openCheckout: (options: Omit<CheckoutOpenOptions, "sessionToken" | "apiUrl">) => Promise<CheckoutResult>;
+    closeCheckout: () => void;
+    isLoading: boolean;
+    error: Error | null;
+};
+
+/**
+ * Query keys for entitlement-related queries
+ */
+declare const entitlementKeys: {
+    all: readonly ["entitlements"];
+    lists: () => readonly ["entitlements", "list"];
+    list: (customerId: string) => readonly ["entitlements", "list", string];
+    checks: () => readonly ["entitlements", "check"];
+    check: (customerId: string, featureKey: string) => readonly ["entitlements", "check", string, string];
+    usage: (customerId: string, featureKey: string) => readonly ["entitlements", "usage", string, string];
+};
+/**
+ * Check if a customer has access to a specific feature
+ *
+ * @param customerId - Customer ID to check
+ * @param featureKey - Feature key to check access for
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * function FeatureGate({ children }: { children: React.ReactNode }) {
+ *   const { data: entitlement, isLoading } = useCheckEntitlement(
+ *     'cus_123',
+ *     'advanced_analytics'
+ *   )
+ *
+ *   if (isLoading) return <div>Checking access...</div>
+ *   if (!entitlement?.has_access) {
+ *     return <UpgradePrompt feature="advanced_analytics" />
+ *   }
+ *
+ *   return <>{children}</>
+ * }
+ * ```
+ */
+declare function useCheckEntitlement(customerId: string, featureKey: string, options?: Omit<UseQueryOptions<Entitlement>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<Entitlement, Error>;
+/**
+ * Simplified hook to check if a customer has access to a feature
+ * Returns a boolean directly instead of the full Entitlement object
+ *
+ * @param customerId - Customer ID to check
+ * @param featureKey - Feature key to check access for
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * function PremiumFeature() {
+ *   const hasAccess = useHasFeature('cus_123', 'premium_features')
+ *
+ *   if (!hasAccess) {
+ *     return <div>Upgrade to access this feature</div>
+ *   }
+ *
+ *   return <div>Premium feature content here</div>
+ * }
+ * ```
+ */
+declare function useHasFeature(customerId: string, featureKey: string, options?: Omit<UseQueryOptions<Entitlement>, 'queryKey' | 'queryFn'>): boolean;
+/**
+ * Get all entitlements for a customer
+ *
+ * @param customerId - Customer ID
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * function EntitlementsList({ customerId }: { customerId: string }) {
+ *   const { data: entitlements, isLoading } = useEntitlements(customerId)
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *
+ *   return (
+ *     <ul>
+ *       {entitlements?.map(entitlement => (
+ *         <li key={entitlement.feature_key}>
+ *           {entitlement.feature_key}: {entitlement.has_access ? '✓' : '✗'}
+ *           {entitlement.limit && ` (${entitlement.usage}/${entitlement.limit})`}
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   )
+ * }
+ * ```
+ */
+declare function useEntitlements(customerId: string, options?: Omit<UseQueryOptions<Entitlement[]>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<Entitlement[], Error>;
+/**
+ * Check if a customer is approaching their usage limit
+ *
+ * @param customerId - Customer ID
+ * @param featureKey - Feature key
+ * @param threshold - Threshold percentage (0-100) to warn at (default: 80)
+ * @param options - React Query options
+ * @returns Boolean indicating if customer is approaching limit
+ *
+ * @example
+ * ```tsx
+ * function UsageWarning({ customerId }: { customerId: string }) {
+ *   const isApproachingLimit = useIsApproachingLimit(
+ *     customerId,
+ *     'api_calls',
+ *     80 // Warn at 80%
+ *   )
+ *
+ *   if (!isApproachingLimit) return null
+ *
+ *   return (
+ *     <Alert variant="warning">
+ *       You're approaching your API call limit. Upgrade to increase your quota.
+ *     </Alert>
+ *   )
+ * }
+ * ```
+ */
+declare function useIsApproachingLimit(customerId: string, featureKey: string, threshold?: number, options?: Omit<UseQueryOptions<UsageMetrics>, 'queryKey' | 'queryFn'>): boolean;
+
+/**
+ * Feature access response
+ */
+interface FeatureAccess {
+    feature_key: string;
+    has_access: boolean;
+    limit?: number;
+    usage?: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Feature entitlement
+ */
+interface FeatureEntitlement {
+    feature_key: string;
+    feature_title: string;
+    feature_type: 'boolean_flag' | 'usage_quota' | 'numeric_limit';
+    granted_at: string;
+    product_name: string;
+    subscription_status: string;
+    properties?: Record<string, any>;
+}
+/**
+ * Usage metric
+ */
+interface UsageMetric {
+    feature_key: string;
+    feature_title: string;
+    product_name: string;
+    consumed: number;
+    limit: number;
+    remaining: number;
+    percentage_used: number;
+    period_start: string;
+    period_end: string;
+    resets_in_days: number;
+}
+/**
+ * Hook to check if user has access to a feature
+ */
+declare function useFeature(featureKey: string, options?: {
+    refetchInterval?: number;
+    enabled?: boolean;
+}): _tanstack_react_query.UseQueryResult<FeatureAccess, Error>;
+/**
+ * Hook to track usage for a feature
+ */
+declare function useTrackUsage(): _tanstack_react_query.UseMutationResult<unknown, Error, {
+    featureKey: string;
+    quantity: number;
+    metadata?: Record<string, any>;
+}, unknown>;
+/**
+ * Hook to get all feature entitlements for the current user
+ */
+declare function useFeatureEntitlements(): _tanstack_react_query.UseQueryResult<{
+    entitlements: FeatureEntitlement[];
+}, Error>;
+/**
+ * Hook to get usage metrics for features
+ */
+declare function useUsageMetrics(featureKey?: string): _tanstack_react_query.UseQueryResult<{
+    metrics: UsageMetric[];
+}, Error>;
+/**
+ * Hook that combines feature access check and tracks when access is denied
+ */
+declare function useFeatureGate(featureKey: string, options?: {
+    onAccessDenied?: () => void;
+    onQuotaExceeded?: (usage: number, limit: number) => void;
+}): {
+    hasAccess: boolean;
+    isQuotaExceeded: boolean;
+    usage: number;
+    limit: number;
+    remaining: number;
+    data: FeatureAccess;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FeatureAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FeatureAccess>;
+} | {
+    hasAccess: boolean;
+    isQuotaExceeded: boolean;
+    usage: number;
+    limit: number;
+    remaining: number;
+    data: FeatureAccess;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FeatureAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FeatureAccess>;
+} | {
+    hasAccess: boolean;
+    isQuotaExceeded: boolean;
+    usage: number;
+    limit: number;
+    remaining: number;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FeatureAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FeatureAccess>;
+} | {
+    hasAccess: boolean;
+    isQuotaExceeded: boolean;
+    usage: number;
+    limit: number;
+    remaining: number;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FeatureAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FeatureAccess>;
+} | {
+    hasAccess: boolean;
+    isQuotaExceeded: boolean;
+    usage: number;
+    limit: number;
+    remaining: number;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FeatureAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FeatureAccess>;
+} | {
+    hasAccess: boolean;
+    isQuotaExceeded: boolean;
+    usage: number;
+    limit: number;
+    remaining: number;
+    data: FeatureAccess;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FeatureAccess, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<FeatureAccess>;
+};
+
+interface Product {
+    id: string;
+    name: string;
+    description?: string;
+    features?: string[];
+    prices?: Price[];
+}
+interface Price {
+    id: string;
+    amount: number;
+    currency: string;
+    interval?: string;
+    interval_count?: number;
+}
+/**
+ * Hook to fetch products for pricing table
+ */
+declare function useProducts$1(): _tanstack_react_query.UseQueryResult<{
+    products: Product[];
+}, Error>;
+
+declare const Alert: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "success" | "default" | "destructive" | "warning" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "success" | "default" | "destructive" | "warning" | "secondary" | "outline" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "secondary" | "outline" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const Card: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+
+interface CheckboxProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const Checkbox: React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLInputElement>>;
+
+interface DialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React$1.ReactNode;
+}
+declare function Dialog({ open, onOpenChange, children }: DialogProps): react_jsx_runtime.JSX.Element;
+interface DialogTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface DialogPortalProps {
+    children: React$1.ReactNode;
+}
+declare function DialogPortal({ children }: DialogPortalProps): react_jsx_runtime.JSX.Element | null;
+declare const DialogOverlay: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+interface DrawerProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React$1.ReactNode;
+}
+declare function Drawer({ open, onOpenChange, children }: DrawerProps): react_jsx_runtime.JSX.Element;
+interface DrawerTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const DrawerTrigger: React$1.ForwardRefExoticComponent<DrawerTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DrawerClose: React$1.ForwardRefExoticComponent<React$1.ButtonHTMLAttributes<HTMLButtonElement> & React$1.RefAttributes<HTMLButtonElement>>;
+interface DrawerContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Whether to prevent closing when clicking outside or pressing ESC
+     */
+    preventClose?: boolean;
+    /**
+     * Callback when user attempts to close but it's prevented
+     */
+    onCloseAttempt?: () => void;
+}
+declare const DrawerContent: React$1.ForwardRefExoticComponent<DrawerContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DrawerHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DrawerFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DrawerTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DrawerDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const Input: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const labelVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+interface LabelProps extends React$1.LabelHTMLAttributes<HTMLLabelElement>, VariantProps<typeof labelVariants> {
+}
+declare const Label: React$1.ForwardRefExoticComponent<LabelProps & React$1.RefAttributes<HTMLLabelElement>>;
+
+interface ProgressProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    value?: number;
+    max?: number;
+    indicatorClassName?: string;
+}
+declare const Progress: React$1.ForwardRefExoticComponent<ProgressProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface RadioGroupProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    name?: string;
+}
+declare const RadioGroup: React$1.ForwardRefExoticComponent<RadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+interface RadioGroupItemProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    value: string;
+}
+declare const RadioGroupItem: React$1.ForwardRefExoticComponent<RadioGroupItemProps & React$1.RefAttributes<HTMLInputElement>>;
+
+interface ScrollAreaProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * The orientation of the scrollable area
+     */
+    orientation?: 'vertical' | 'horizontal' | 'both';
+    /**
+     * Always show the custom scrollbar (instead of only on hover)
+     */
+    alwaysShowScrollbar?: boolean;
+}
+declare const ScrollArea: React$1.ForwardRefExoticComponent<ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+    orientation?: "vertical" | "horizontal";
+} & React$1.RefAttributes<HTMLDivElement>>;
+
+interface SelectProps extends React$1.SelectHTMLAttributes<HTMLSelectElement> {
+    onValueChange?: (value: string) => void;
+}
+declare const Select: React$1.ForwardRefExoticComponent<SelectProps & React$1.RefAttributes<HTMLSelectElement>>;
+declare const SelectOption: React$1.ForwardRefExoticComponent<React$1.OptionHTMLAttributes<HTMLOptionElement> & React$1.RefAttributes<HTMLOptionElement>>;
+
+interface SeparatorProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    orientation?: 'horizontal' | 'vertical';
+    decorative?: boolean;
+}
+declare const Separator: React$1.ForwardRefExoticComponent<SeparatorProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface SheetProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React$1.ReactNode;
+}
+declare function Sheet({ open, onOpenChange, children }: SheetProps): react_jsx_runtime.JSX.Element;
+interface SheetTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const SheetTrigger: React$1.ForwardRefExoticComponent<SheetTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React$1.ForwardRefExoticComponent<React$1.ButtonHTMLAttributes<HTMLButtonElement> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "left" | "right" | "bottom" | "top" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SheetContentProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+interface TabsProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+}
+declare const Tabs: React$1.ForwardRefExoticComponent<TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+interface TabsTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    value: string;
+}
+declare const TabsTrigger: React$1.ForwardRefExoticComponent<TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface TabsContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    value: string;
+}
+declare const TabsContent: React$1.ForwardRefExoticComponent<TabsContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Textarea: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+type PortalTab = 'subscription' | 'invoices' | 'payment' | 'settings';
+interface CustomerPortalProps {
+    /**
+     * Open/close state (for drawer/modal mode)
+     */
+    isOpen?: boolean;
+    /**
+     * Callback when user closes portal
+     */
+    onClose?: () => void;
+    /**
+     * Display mode
+     * - 'drawer': Slide-in from right (default)
+     * - 'modal': Centered modal
+     * - 'page': Full-page view
+     */
+    mode?: 'drawer' | 'modal' | 'page';
+    /**
+     * Default tab to show
+     */
+    defaultTab?: PortalTab;
+    /**
+     * Optional: Custom theme
+     */
+    theme?: 'light' | 'dark';
+    /**
+     * Optional: Custom class name
+     */
+    className?: string;
+    /**
+     * Optional: Customer ID to load specific customer
+     */
+    customerId?: string;
+    /**
+     * Optional: Custom metadata
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Callback when subscription is updated
+     */
+    onSubscriptionUpdate?: (subscription: any) => void;
+    /**
+     * Callback when subscription is cancelled
+     */
+    onSubscriptionCancel?: () => void;
+    /**
+     * Callback when payment method is added
+     */
+    onPaymentMethodAdd?: () => void;
+    /**
+     * Callback when payment method is updated
+     */
+    onPaymentMethodUpdate?: () => void;
+    /**
+     * Debug mode for development
+     */
+    debug?: boolean;
+}
+declare function CustomerPortal({ isOpen, onClose, mode, defaultTab, theme, className, customerId, metadata, onSubscriptionUpdate, onSubscriptionCancel, onPaymentMethodAdd, onPaymentMethodUpdate, debug }: CustomerPortalProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Query keys for portal-related queries
+ */
+declare const portalKeys: {
+    all: readonly ["portal"];
+    data: () => readonly ["portal", "data"];
+    setupIntent: () => readonly ["portal", "setupIntent"];
+};
+/**
+ * Fetch all portal data for the current customer
+ * Returns subscription, invoices, payment methods, customer info, and available plans
+ */
+declare function usePortalData(options?: Omit<UseQueryOptions<CustomerPortalData>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<CustomerPortalData, Error>;
+/**
+ * Update subscription (upgrade/downgrade)
+ */
+declare function useUpdatePortalSubscription(subscriptionId: string, options?: Omit<UseMutationOptions<PortalUpdateSubscriptionResponse, Error, PortalUpdateSubscriptionInput>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<PortalUpdateSubscriptionResponse, Error, PortalUpdateSubscriptionInput, unknown>;
+/**
+ * Cancel subscription with feedback
+ */
+declare function useCancelPortalSubscription(subscriptionId: string, options?: Omit<UseMutationOptions<PortalCancelSubscriptionResponse, Error, PortalCancelSubscriptionInput>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<PortalCancelSubscriptionResponse, Error, PortalCancelSubscriptionInput, unknown>;
+/**
+ * Reactivate a canceled subscription
+ */
+declare function useReactivatePortalSubscription(subscriptionId: string, options?: Omit<UseMutationOptions<void, Error, void>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<void, Error, void, unknown>;
+/**
+ * Get setup intent for adding a new payment method
+ */
+declare function useSetupIntent(options?: Omit<UseQueryOptions<SetupIntentResponse>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<SetupIntentResponse, Error>;
+/**
+ * Add a payment method
+ */
+declare function useAddPaymentMethod(options?: Omit<UseMutationOptions<AddPaymentMethodResponse, Error, AddPaymentMethodInput>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<AddPaymentMethodResponse, Error, AddPaymentMethodInput, unknown>;
+/**
+ * Remove a payment method
+ */
+declare function useRemovePaymentMethod(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
+/**
+ * Set default payment method
+ */
+declare function useSetDefaultPaymentMethod(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
+/**
+ * Retry a failed invoice
+ */
+declare function useRetryInvoice(options?: Omit<UseMutationOptions<RetryInvoiceResponse, Error, {
+    invoiceId: string;
+    paymentMethodId?: string;
+}>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<RetryInvoiceResponse, Error, {
+    invoiceId: string;
+    paymentMethodId?: string;
+}, unknown>;
+/**
+ * Update customer billing information
+ */
+declare function useUpdateCustomerBilling(options?: Omit<UseMutationOptions<CustomerBillingInfo, Error, UpdateCustomerBillingInput>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<CustomerBillingInfo, Error, UpdateCustomerBillingInput, unknown>;
+
+interface SubscriptionTabProps {
+    subscription: PortalSubscription | null;
+    availablePlans: PortalAvailablePlan[];
+    onChangePlan: () => void;
+    onCancelSubscription: () => void;
+    onReactivate: () => void;
+    onAddPaymentMethod: () => void;
+    isLoading?: boolean;
+    className?: string;
+}
+declare function SubscriptionTab({ subscription, onChangePlan, onCancelSubscription, onReactivate, onAddPaymentMethod, isLoading, className, }: SubscriptionTabProps): react_jsx_runtime.JSX.Element;
+
+interface InvoicesTabProps {
+    invoices: PortalInvoice[];
+    onRetryInvoice: (invoiceId: string) => void;
+    onDownloadInvoice: (pdfUrl: string) => void;
+    retryingInvoiceId?: string;
+    isLoading?: boolean;
+    className?: string;
+}
+declare function InvoicesTab({ invoices, onRetryInvoice, onDownloadInvoice, retryingInvoiceId, isLoading, className, }: InvoicesTabProps): react_jsx_runtime.JSX.Element;
+
+interface PaymentMethodsTabProps {
+    paymentMethods: PortalPaymentMethod[];
+    onAddPaymentMethod: () => void;
+    onSetDefault: (id: string) => void;
+    onRemove: (id: string) => void;
+    settingDefaultId?: string;
+    removingId?: string;
+    isLoading?: boolean;
+    className?: string;
+}
+declare function PaymentMethodsTab({ paymentMethods, onAddPaymentMethod, onSetDefault, onRemove, settingDefaultId, removingId, isLoading, className, }: PaymentMethodsTabProps): react_jsx_runtime.JSX.Element;
+
+interface SettingsTabProps {
+    customer: PortalCustomer;
+    onSave: (data: {
+        name?: string;
+        email?: string;
+        billingAddress?: PortalAddress;
+    }) => void;
+    isSaving?: boolean;
+    isLoading?: boolean;
+    className?: string;
+}
+declare function SettingsTab({ customer, onSave, isSaving, isLoading, className, }: SettingsTabProps): react_jsx_runtime.JSX.Element;
+
+interface UsageBarProps {
+    title: string;
+    usage: PortalUsageInfo;
+    unit?: string;
+    className?: string;
+}
+declare function UsageBar({ title, usage, unit, className }: UsageBarProps): react_jsx_runtime.JSX.Element;
+
+interface FeatureListProps {
+    features: PortalFeatureWithUsage[];
+    className?: string;
+}
+declare function FeatureList({ features, className }: FeatureListProps): react_jsx_runtime.JSX.Element | null;
+
+interface InvoiceCardProps {
+    invoice: PortalInvoice;
+    onRetry?: (invoiceId: string) => void;
+    onDownload?: (pdfUrl: string) => void;
+    isRetrying?: boolean;
+    className?: string;
+}
+declare function InvoiceCard({ invoice, onRetry, onDownload, isRetrying, className, }: InvoiceCardProps): react_jsx_runtime.JSX.Element;
+
+interface PaymentMethodCardProps {
+    paymentMethod: PortalPaymentMethod;
+    onSetDefault?: (id: string) => void;
+    onRemove?: (id: string) => void;
+    isSettingDefault?: boolean;
+    isRemoving?: boolean;
+    className?: string;
+}
+declare function PaymentMethodCard({ paymentMethod, onSetDefault, onRemove, isSettingDefault, isRemoving, className, }: PaymentMethodCardProps): react_jsx_runtime.JSX.Element | null;
+
+interface WarningBannerProps {
+    type: 'trial_ending' | 'payment_failed' | 'subscription_canceled' | 'past_due';
+    message: string;
+    actionLabel?: string;
+    onAction?: () => void;
+    className?: string;
+}
+declare function WarningBanner({ type, message, actionLabel, onAction, className, }: WarningBannerProps): react_jsx_runtime.JSX.Element;
+
+interface ChangePlanModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    subscriptionId: string;
+    onSuccess?: () => void;
+}
+declare function ChangePlanModal({ open, onOpenChange, subscriptionId, onSuccess, }: ChangePlanModalProps): react_jsx_runtime.JSX.Element;
+
+interface CancelSubscriptionModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    periodEndDate: string;
+    onConfirm: (input: PortalCancelSubscriptionInput) => void;
+    isCanceling?: boolean;
+}
+declare function CancelSubscriptionModal({ open, onOpenChange, periodEndDate, onConfirm, isCanceling, }: CancelSubscriptionModalProps): react_jsx_runtime.JSX.Element;
+
+interface AddPaymentMethodModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSuccess: (paymentMethodId: string, setAsDefault: boolean) => void;
+    clientSecret?: string;
+    stripePublishableKey?: string;
+    isLoading?: boolean;
+}
+declare function AddPaymentMethodModal({ open, onOpenChange, onSuccess, clientSecret, stripePublishableKey, isLoading, }: AddPaymentMethodModalProps): react_jsx_runtime.JSX.Element;
+
+interface PaymentBottomSheetProps {
+    /**
+     * Price ID to purchase
+     */
+    priceId: string;
+    /**
+     * Open/close state
+     */
+    isOpen: boolean;
+    /**
+     * Callback when user closes sheet
+     */
+    onClose: () => void;
+    /**
+     * Callback when payment succeeds
+     */
+    onSuccess: (subscriptionId: string) => void;
+    /**
+     * Optional: Subscription ID if upgrading
+     */
+    existingSubscriptionId?: string;
+    /**
+     * Optional: Custom theme
+     */
+    theme?: 'light' | 'dark';
+}
+declare function PaymentBottomSheet({ priceId, isOpen, onClose, onSuccess, existingSubscriptionId, theme, }: PaymentBottomSheetProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hook to create a checkout session
+ */
+declare function useCreateCheckout(input: CreateCheckoutInput | null, options?: {
+    enabled?: boolean;
+    onSuccess?: (data: CreateCheckoutResponse) => void;
+    onError?: (error: Error) => void;
+}): _tanstack_react_query.UseQueryResult<CheckoutSession, Error>;
+/**
+ * Hook to confirm a checkout after payment
+ */
+declare function useConfirmCheckout(options?: {
+    onSuccess?: (data: ConfirmCheckoutResponse) => void;
+    onError?: (error: Error) => void;
+}): _tanstack_react_query.UseMutationResult<ConfirmCheckoutResponse, Error, {
+    clientSecret: string;
+    paymentMethodId: string;
+}, unknown>;
+
+interface CheckoutModalProps {
+    /**
+     * Whether the modal is open
+     */
+    open: boolean;
+    /**
+     * Callback when the modal open state changes
+     */
+    onOpenChange: (open: boolean) => void;
+    /**
+     * The price ID to checkout
+     */
+    priceId: string;
+    /**
+     * Customer information to pre-populate
+     */
+    customer?: {
+        email?: string;
+        name?: string;
+        taxId?: string;
+    };
+    /**
+     * Coupon code to apply
+     */
+    couponCode?: string;
+    /**
+     * Whether to collect billing address
+     */
+    collectBillingAddress?: boolean;
+    /**
+     * Currency for the checkout (defaults to price currency)
+     */
+    currency?: string;
+    /**
+     * Existing subscription ID for upgrades/downgrades
+     */
+    existingSubscriptionId?: string;
+    /**
+     * Custom metadata to attach to the subscription
+     */
+    metadata?: Record<string, string>;
+    /**
+     * Theme for the checkout modal
+     */
+    theme?: 'light' | 'dark' | 'auto';
+    /**
+     * Locale for the checkout (e.g., 'en', 'es', 'fr')
+     */
+    locale?: string;
+    /**
+     * Success callback with the created subscription
+     */
+    onSuccess: (subscription: any) => void;
+    /**
+     * Error callback
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Cancel callback when user closes without completing
+     */
+    onCancel?: () => void;
+    /**
+     * Debug mode for development
+     */
+    debug?: boolean;
+}
+declare function CheckoutModal({ open, onOpenChange, priceId, customer, couponCode, collectBillingAddress, existingSubscriptionId, metadata, theme, locale, onSuccess, onError, onCancel, debug }: CheckoutModalProps): react_jsx_runtime.JSX.Element;
+
+interface PricingTableProps {
+    planIds?: string[];
+    showIntervalToggle?: boolean;
+    defaultInterval?: 'month' | 'year';
+    onSelectPlan?: (priceId: string) => void;
+    theme?: 'light' | 'dark';
+    title?: string;
+    description?: string;
+    /** Use the new iframe-based checkout modal instead of bottom sheet */
+    useCheckoutModal?: boolean;
+    /** Callback when plan is changed (for upgrade/downgrade flows) */
+    onPlanChanged?: (subscription: any) => void;
+    /** Customer information to prefill in checkout (overrides context) */
+    customer?: {
+        email?: string;
+        name?: string;
+    };
+}
+declare function PricingTable({ planIds, showIntervalToggle, defaultInterval, onSelectPlan, theme, title, description, useCheckoutModal, onPlanChanged, customer: customerProp, }: PricingTableProps): react_jsx_runtime.JSX.Element;
+
+interface PricingCardProps {
+    product: PricingProduct;
+    selectedInterval: 'month' | 'year';
+    currentSubscription: PricingCurrentSubscription | null;
+    onSelectPlan: (priceId: string) => void;
+    theme?: 'light' | 'dark';
+}
+declare function PricingCard({ product, selectedInterval, currentSubscription, onSelectPlan, }: PricingCardProps): react_jsx_runtime.JSX.Element;
+
+interface UseProductsOptions {
+    /**
+     * Optional array of plan IDs to filter
+     */
+    planIds?: string[];
+    /**
+     * Whether to enable the query
+     */
+    enabled?: boolean;
+}
+/**
+ * Hook to fetch products for pricing table
+ */
+declare function useProducts(options?: UseProductsOptions): _tanstack_react_query.UseQueryResult<GetProductsResponse, Error>;
+
+interface UpgradeNudgeProps {
+    /**
+     * Nudge trigger data (from API or usage check)
+     */
+    trigger: NudgeTrigger;
+    /**
+     * Display style
+     * - 'banner': Top banner (non-intrusive)
+     * - 'toast': Toast notification (bottom-right)
+     * - 'modal': Modal dialog (more prominent)
+     */
+    style?: 'banner' | 'toast' | 'modal';
+    /**
+     * Auto-dismiss after N milliseconds (0 = no auto-dismiss)
+     */
+    autoDismiss?: number;
+    /**
+     * Callback when user clicks upgrade
+     */
+    onUpgrade?: (priceId: string) => void;
+    /**
+     * Callback when user dismisses nudge
+     */
+    onDismiss?: () => void;
+    /**
+     * Optional: Custom theme
+     */
+    theme?: 'light' | 'dark';
+}
+declare function UpgradeNudge({ trigger, style, autoDismiss, onUpgrade, onDismiss, theme, }: UpgradeNudgeProps): react_jsx_runtime.JSX.Element | null;
+
+interface BannerNudgeProps {
+    trigger: NudgeTrigger;
+    onUpgrade: () => void;
+    onDismiss: () => void;
+    theme?: 'light' | 'dark';
+}
+declare function BannerNudge({ trigger, onUpgrade, onDismiss, }: BannerNudgeProps): react_jsx_runtime.JSX.Element;
+
+interface ToastNudgeProps {
+    trigger: NudgeTrigger;
+    onUpgrade: () => void;
+    onDismiss: () => void;
+    theme?: 'light' | 'dark';
+}
+declare function ToastNudge({ trigger, onUpgrade, onDismiss, }: ToastNudgeProps): react_jsx_runtime.JSX.Element;
+
+interface ModalNudgeProps {
+    trigger: NudgeTrigger;
+    onUpgrade: () => void;
+    onDismiss: () => void;
+    theme?: 'light' | 'dark';
+}
+declare function ModalNudge({ trigger, onUpgrade, onDismiss, }: ModalNudgeProps): react_jsx_runtime.JSX.Element;
+
+interface UseUsageCheckOptions {
+    /**
+     * Whether to enable the query
+     */
+    enabled?: boolean;
+    /**
+     * Refetch interval in milliseconds (0 = no auto refetch)
+     */
+    refetchInterval?: number;
+}
+/**
+ * Hook to check usage and get nudge trigger
+ */
+declare function useUsageCheck(options?: UseUsageCheckOptions): _tanstack_react_query.UseQueryResult<UsageCheckResponse, Error>;
+
+interface FeatureGateProps {
+    /**
+     * The feature key to check access for
+     */
+    feature: string;
+    /**
+     * Content to render when user has access
+     */
+    children: React__default.ReactNode;
+    /**
+     * Content to render when access is denied (optional)
+     */
+    fallback?: React__default.ReactNode;
+    /**
+     * Content to render while loading (optional)
+     */
+    loading?: React__default.ReactNode;
+    /**
+     * Callback when access is denied
+     */
+    onAccessDenied?: () => void;
+    /**
+     * Callback when quota is exceeded
+     */
+    onQuotaExceeded?: (usage: number, limit: number) => void;
+    /**
+     * Whether to show remaining usage in a badge
+     */
+    showUsageBadge?: boolean;
+}
+/**
+ * FeatureGate component for conditional rendering based on feature access
+ *
+ * @example
+ * ```tsx
+ * <FeatureGate
+ *   feature="advanced_analytics"
+ *   fallback={<UpgradePrompt feature="Advanced Analytics" />}
+ * >
+ *   <AdvancedAnalyticsDashboard />
+ * </FeatureGate>
+ * ```
+ */
+declare function FeatureGate({ feature, children, fallback, loading, onAccessDenied, onQuotaExceeded, showUsageBadge, }: FeatureGateProps): react_jsx_runtime.JSX.Element;
+
+interface UsageDisplayProps {
+    /**
+     * Optional feature key to show usage for specific feature
+     */
+    featureKey?: string;
+    /**
+     * Custom title
+     */
+    title?: string;
+    /**
+     * Whether to show a progress bar
+     */
+    showProgress?: boolean;
+    /**
+     * Whether to show reset timer
+     */
+    showResetTimer?: boolean;
+    /**
+     * Custom className for styling
+     */
+    className?: string;
+}
+/**
+ * Component to display usage metrics for features
+ *
+ * @example
+ * ```tsx
+ * // Show all usage metrics
+ * <UsageDisplay />
+ *
+ * // Show specific feature usage
+ * <UsageDisplay featureKey="api_calls" />
+ * ```
+ */
+declare function UsageDisplay({ featureKey, title, showProgress, showResetTimer, className, }: UsageDisplayProps): react_jsx_runtime.JSX.Element;
+/**
+ * Compact usage display for inline use
+ */
+declare function CompactUsageDisplay({ featureKey, className, }: {
+    featureKey: string;
+    className?: string;
+}): react_jsx_runtime.JSX.Element | null;
+
+interface UpgradePromptProps {
+    /**
+     * Feature that requires upgrade
+     */
+    feature?: string;
+    /**
+     * Title text
+     */
+    title?: string;
+    /**
+     * Description text
+     */
+    description?: string;
+    /**
+     * Whether it's a quota exceeded prompt
+     */
+    isQuotaExceeded?: boolean;
+    /**
+     * Current usage (for quota exceeded)
+     */
+    usage?: number;
+    /**
+     * Usage limit (for quota exceeded)
+     */
+    limit?: number;
+    /**
+     * Custom className for styling
+     */
+    className?: string;
+    /**
+     * Click handler for upgrade button
+     */
+    onUpgradeClick?: () => void;
+}
+/**
+ * Component that prompts users to upgrade when they hit limits or access denied features
+ *
+ * @example
+ * ```tsx
+ * <UpgradePrompt
+ *   feature="Advanced Analytics"
+ *   description="Upgrade to Pro to access advanced analytics and reporting"
+ * />
+ * ```
+ */
+declare function UpgradePrompt({ feature, title, description, isQuotaExceeded, usage, limit, className, onUpgradeClick, }: UpgradePromptProps): react_jsx_runtime.JSX.Element;
+/**
+ * Compact upgrade prompt for inline use
+ */
+declare function CompactUpgradePrompt({ feature, onUpgradeClick, className, }: {
+    feature?: string;
+    onUpgradeClick?: () => void;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Context value provided by BillingOSProvider
+ */
+interface BillingOSContextValue {
+    client: BillingOSClient | null;
+    apiUrl: string;
+    appUrl: string;
+    customerId?: string;
+    customerEmail?: string;
+    customerName?: string;
+    organizationId?: string;
+    debug: boolean;
+}
+interface BillingOSProviderProps {
+    /**
+     * @deprecated The SDK now auto-detects the API URL from the session token prefix.
+     * Only use this for internal development to override the auto-detected URL.
+     */
+    apiUrl?: string;
+    /**
+     * @deprecated The app URL is now always https://app.billingos.dev.
+     * Only use this for internal development to override the default.
+     */
+    appUrl?: string;
+    /**
+     * URL to fetch session token from (e.g., /api/billingos-session).
+     * The SDK will automatically fetch and refresh the token.
+     */
+    sessionTokenUrl?: string;
+    /**
+     * Provide a session token directly instead of auto-fetching.
+     */
+    sessionToken?: string;
+    /**
+     * Session token auto-refresh configuration.
+     */
+    sessionTokenOptions?: Omit<UseSessionTokenOptions, 'token' | 'tokenUrl'>;
+    /**
+     * Rendered while the session token is being fetched.
+     * Defaults to rendering children (app is visible immediately, billing components show their own loading state).
+     */
+    loadingFallback?: React__default.ReactNode;
+    /**
+     * Optional customer context passed to all hooks and components.
+     */
+    customerId?: string;
+    customerEmail?: string;
+    customerName?: string;
+    organizationId?: string;
+    /**
+     * Additional client configuration (headers, timeout, etc.).
+     */
+    options?: BillingOSClientOptions;
+    /**
+     * Inject a custom TanStack QueryClient.
+     */
+    queryClient?: QueryClient;
+    /**
+     * Enable debug logging. Off by default.
+     */
+    debug?: boolean;
+    children: React__default.ReactNode;
+}
+declare function BillingOSProvider({ apiUrl: apiUrlProp, appUrl: appUrlProp, sessionToken: manualSessionToken, sessionTokenUrl, sessionTokenOptions, loadingFallback, customerId, customerEmail, customerName, organizationId, options, queryClient, debug, children, }: BillingOSProviderProps): react_jsx_runtime.JSX.Element;
+declare function useBillingOS(): BillingOSContextValue;
+
+/**
+ * Currency utilities for formatting and converting money values
+ */
+/**
+ * Convert cents to dollar string
+ * @param cents - Amount in cents
+ * @param showCents - Force showing cents even if amount is whole dollars
+ * @param pretty - Use locale formatting with thousand separators
+ * @returns Formatted dollar string
+ *
+ * @example
+ * getCentsInDollarString(1000) // "10"
+ * getCentsInDollarString(1050, true) // "10.50"
+ * getCentsInDollarString(1000000, false, true) // "10,000"
+ */
+declare const getCentsInDollarString: (cents: number, showCents?: boolean, pretty?: boolean) => string;
+/**
+ * Format cents as currency with symbol
+ * @param cents - Amount in cents
+ * @param currency - Currency code (e.g., 'USD', 'EUR')
+ * @param minimumFractionDigits - Minimum decimal places
+ * @param notation - Number notation style
+ * @param maximumFractionDigits - Maximum decimal places
+ * @returns Formatted currency string with symbol
+ *
+ * @example
+ * formatCurrencyAndAmount(1050, 'USD') // "$10.50"
+ * formatCurrencyAndAmount(1000000, 'USD', 0, 'compact') // "$10K"
+ * formatCurrencyAndAmount(5000, 'EUR') // "€50.00"
+ */
+declare const formatCurrencyAndAmount: (cents: number, currency: string, minimumFractionDigits?: number, notation?: "standard" | "scientific" | "engineering" | "compact", maximumFractionDigits?: number) => string;
+/**
+ * Convert cents to float (dollars)
+ * @param cents - Amount in cents
+ * @returns Amount in dollars as a float
+ *
+ * @example
+ * convertCentsToFloat(1050) // 10.5
+ */
+declare const convertCentsToFloat: (cents: number) => number;
+/**
+ * Convert float (dollars) to cents
+ * @param amount - Amount in dollars
+ * @returns Amount in cents as an integer
+ *
+ * @example
+ * convertFloatToCents(10.5) // 1050
+ */
+declare const convertFloatToCents: (amount: number) => number;
+/**
+ * Format currency in compact notation (e.g., $1.2K, $3.5M)
+ * @param cents - Amount in cents
+ * @param currency - Currency code
+ * @returns Compact formatted currency string
+ *
+ * @example
+ * formatCurrencyCompact(1200000, 'USD') // "$12K"
+ * formatCurrencyCompact(3500000000, 'USD') // "$35M"
+ */
+declare const formatCurrencyCompact: (cents: number, currency: string) => string;
+/**
+ * Format currency without cents (whole dollars only)
+ * @param cents - Amount in cents
+ * @param currency - Currency code
+ * @returns Formatted currency string without cents
+ *
+ * @example
+ * formatCurrencyWhole(1050, 'USD') // "$10"
+ * formatCurrencyWhole(1099, 'USD') // "$11" (rounds)
+ */
+declare const formatCurrencyWhole: (cents: number, currency: string) => string;
+/**
+ * Get currency symbol for a currency code
+ * @param currency - Currency code (e.g., 'USD', 'EUR')
+ * @returns Currency symbol (e.g., '$', '€')
+ *
+ * @example
+ * getCurrencySymbol('USD') // "$"
+ * getCurrencySymbol('EUR') // "€"
+ * getCurrencySymbol('GBP') // "£"
+ */
+declare const getCurrencySymbol: (currency: string) => string;
+/**
+ * Format a price range (e.g., "$10 - $50")
+ * @param minCents - Minimum amount in cents
+ * @param maxCents - Maximum amount in cents
+ * @param currency - Currency code
+ * @returns Formatted price range string
+ *
+ * @example
+ * formatPriceRange(1000, 5000, 'USD') // "$10 - $50"
+ */
+declare const formatPriceRange: (minCents: number, maxCents: number, currency: string) => string;
+/**
+ * Check if an amount is zero
+ * @param cents - Amount in cents
+ * @returns True if amount is zero
+ */
+declare const isZeroAmount: (cents: number) => boolean;
+/**
+ * Check if an amount is negative
+ * @param cents - Amount in cents
+ * @returns True if amount is negative
+ */
+declare const isNegativeAmount: (cents: number) => boolean;
+/**
+ * Calculate percentage of an amount
+ * @param cents - Amount in cents
+ * @param percentage - Percentage (0-100)
+ * @returns Calculated amount in cents
+ *
+ * @example
+ * calculatePercentage(10000, 20) // 2000 (20% of $100)
+ */
+declare const calculatePercentage: (cents: number, percentage: number) => number;
+/**
+ * Add amounts together
+ * @param amounts - Array of amounts in cents
+ * @returns Sum in cents
+ *
+ * @example
+ * addAmounts([1000, 2000, 3000]) // 6000
+ */
+declare const addAmounts: (...amounts: number[]) => number;
+/**
+ * Money utilities namespace for convenience
+ */
+declare const Money: {
+    format: (cents: number, currency: string, minimumFractionDigits?: number, notation?: "standard" | "scientific" | "engineering" | "compact", maximumFractionDigits?: number) => string;
+    formatCompact: (cents: number, currency: string) => string;
+    formatWhole: (cents: number, currency: string) => string;
+    formatRange: (minCents: number, maxCents: number, currency: string) => string;
+    fromCents: (cents: number) => number;
+    toCents: (amount: number) => number;
+    getSymbol: (currency: string) => string;
+    isZero: (cents: number) => boolean;
+    isNegative: (cents: number) => boolean;
+    calculatePercentage: (cents: number, percentage: number) => number;
+    add: (...amounts: number[]) => number;
+};
+
+/**
+ * Format a date string or Date object
+ * @param date - Date string (ISO) or Date object
+ * @param formatStr - Format string (date-fns format)
+ * @returns Formatted date string
+ *
+ * @example
+ * formatDate('2024-01-15T10:30:00Z', 'PPP') // "January 15th, 2024"
+ * formatDate(new Date(), 'yyyy-MM-dd') // "2024-01-15"
+ */
+declare const formatDate: (date: string | Date, formatStr?: string) => string;
+/**
+ * Format a date as relative time (e.g., "2 hours ago")
+ * @param date - Date string (ISO) or Date object
+ * @param baseDate - Base date to compare against (defaults to now)
+ * @returns Relative time string
+ *
+ * @example
+ * formatRelativeTime('2024-01-15T08:30:00Z') // "2 hours ago"
+ */
+declare const formatRelativeTime: (date: string | Date, baseDate?: Date) => string;
+/**
+ * Format a date relative to now (e.g., "today at 10:30 AM")
+ * @param date - Date string (ISO) or Date object
+ * @param baseDate - Base date to compare against (defaults to now)
+ * @returns Relative date string
+ *
+ * @example
+ * formatRelativeDate('2024-01-15T10:30:00Z') // "today at 10:30 AM"
+ */
+declare const formatRelativeDate: (date: string | Date, baseDate?: Date) => string;
+/**
+ * Check if a date is in the past
+ * @param date - Date string (ISO) or Date object
+ * @returns True if date is in the past
+ */
+declare const isPast: (date: string | Date) => boolean;
+/**
+ * Check if a date is in the future
+ * @param date - Date string (ISO) or Date object
+ * @returns True if date is in the future
+ */
+declare const isFuture: (date: string | Date) => boolean;
+/**
+ * Parse ISO date string to Date object
+ * @param date - ISO date string
+ * @returns Date object
+ */
+declare const parseDate: (date: string) => Date;
+/**
+ * Date utilities namespace
+ */
+declare const DateUtils: {
+    format: (date: string | Date, formatStr?: string) => string;
+    formatRelative: (date: string | Date, baseDate?: Date) => string;
+    formatRelativeDate: (date: string | Date, baseDate?: Date) => string;
+    isPast: (date: string | Date) => boolean;
+    isFuture: (date: string | Date) => boolean;
+    parse: (date: string) => Date;
+};
+
+/**
+ * Utility function to merge Tailwind CSS classes
+ * Combines clsx for conditional classes with tailwind-merge for deduplication
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * BillingOS production URLs.
+ * These are the defaults — SDK users don't need to configure anything.
+ * The SDK auto-detects the correct API URL from the session token prefix.
+ */
+declare const BILLINGOS_API_URL = "https://api.billingos.dev";
+declare const BILLINGOS_SANDBOX_API_URL = "https://sandbox-api.billingos.dev";
+declare const BILLINGOS_APP_URL = "https://app.billingos.dev";
+/**
+ * Detect environment from session token prefix.
+ */
+declare function detectEnvironmentFromToken(token: string): 'test' | 'live';
+/**
+ * Resolve the BillingOS API URL from a session token prefix.
+ * This is the primary resolution method — no configuration needed.
+ */
+declare function resolveApiUrlFromToken(token: string): string;
+/**
+ * Resolve the BillingOS app URL.
+ * The app URL is the same for both test and live environments.
+ */
+declare function resolveAppUrlFromToken(_token: string): string;
+/**
+ * @deprecated Use resolveApiUrlFromToken() instead. The SDK now auto-detects
+ * the API URL from the session token prefix (bos_session_test_ / bos_session_live_).
+ */
+declare function resolveApiUrl(propUrl?: string): string;
+/**
+ * @deprecated Use resolveAppUrlFromToken() instead. The app URL is now
+ * always https://app.billingos.dev for both test and live environments.
+ */
+declare function resolveAppUrl(propUrl?: string): string;
+
+declare global {
+    interface Window {
+        billingOS?: {
+            checkout: {
+                open: (options: CheckoutOpenOptions) => Promise<{
+                    success: boolean;
+                    subscription?: Subscription;
+                    error?: Error;
+                }>;
+            };
+            client?: BillingOSClient;
+        };
+    }
+}
+
+export { type APIErrorResponse, type AddPaymentMethodInput, AddPaymentMethodModal, type AddPaymentMethodResponse, Alert, AlertDescription, AlertTitle, type AvailablePlan, type AvailablePlansResponse, BILLINGOS_API_URL, BILLINGOS_APP_URL, BILLINGOS_SANDBOX_API_URL, Badge, type BadgeProps, BannerNudge, type BannerNudgeProps, BillingOSClient, type BillingOSClientOptions, type BillingOSContextValue, BillingOSError, BillingOSProvider, type BillingOSProviderProps, Button, type ButtonProps, CancelSubscriptionModal, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, type ChangeEffectiveTiming, type ChangePlanInput, ChangePlanModal, type ChangePlanResponse, type ChangeType, type CheckEntitlementInput, Checkbox, CheckoutAPI, type CheckoutCustomer, CheckoutModal, type CheckoutModalProps, type CheckoutOpenOptions, type CheckoutProduct, type CheckoutProration, type CheckoutResult, type CheckoutSession, type CheckoutSessionDetails, CompactUpgradePrompt, CompactUsageDisplay, type ConfirmCheckoutInput, type ConfirmCheckoutResponse, type CreateCheckoutInput, type CreateCheckoutResponse, type CreateCheckoutSessionInput, type CreateCheckoutSessionResponse, type CreateCustomerInput, type CreateSubscriptionInput, type Customer, type CustomerBillingInfo, CustomerPortal, type CustomerPortalData, type CustomerPortalProps, DateUtils, Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerTitle, DrawerTrigger, type Entitlement, type FeatureAccess, type FeatureEntitlement, FeatureGate, type FeatureGateProps, FeatureList, type GetProductsResponse, Input, type Invoice, InvoiceCard, InvoicesTab, Label, type LabelProps, ModalNudge, type ModalNudgeProps, Money, NetworkError, NotFoundError, type NudgeMessage, type NudgeTrigger, type NudgeTriggerType, type PaginatedResponse, type PaginationMeta, PaymentBottomSheet, type PaymentBottomSheetProps, type PaymentMethod, PaymentMethodCard, PaymentMethodsTab, type PlanInfo, type PortalAddress, type PortalAvailablePlan, type PortalCancelSubscriptionInput, type PortalCancelSubscriptionResponse, type PortalCardDetails, type PortalCustomer, type PortalFeatureType, type PortalFeatureWithUsage, type PortalInvoice, type PortalLineItem, type PortalPaymentMethod, type PortalPrice, type PortalProduct, type PortalSubscription, type PortalUpdateSubscriptionInput, type PortalUpdateSubscriptionResponse, type PortalUsageInfo, type PreviewChangeInput, type PreviewChangeResponse, type Price, PricingCard, type PricingCardProps, type PricingCurrentSubscription, type PricingFeature, type PricingFeatureProperties, type PricingPrice, type PricingProduct, PricingTable, type PricingTableProps, type Product, Progress, type ProrationInfo, RadioGroup, RadioGroupItem, RateLimitError, type RetryInvoiceResponse, ScrollArea, ScrollBar, Select, SelectOption, Separator, ServerError, type SessionTokenData, SettingsTab, type SetupIntentResponse, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, SheetTrigger, Skeleton, type Subscription, type SubscriptionPreview, type SubscriptionStatus, SubscriptionTab, type SuggestedPlan, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, ToastNudge, type ToastNudgeProps, UnauthorizedError, type UpdateCustomerBillingInput, type UpdateCustomerInput, type UpdateSubscriptionInput, UpgradeNudge, type UpgradeNudgeProps, UpgradePrompt, type UpgradePromptProps, UsageBar, type UsageCheckResponse, UsageDisplay, type UsageDisplayProps, type UsageEvent, type UsageMetric, type UsageMetrics, type UseProductsOptions, type UseSessionTokenOptions, type UseSessionTokenReturn, type UseUsageCheckOptions, ValidationError, WarningBanner, addAmounts, badgeVariants, buttonVariants, calculatePercentage, cn, convertCentsToFloat, convertFloatToCents, createBillingOSClient, detectEnvironmentFromToken, entitlementKeys, formatCurrencyAndAmount, formatCurrencyCompact, formatCurrencyWhole, formatDate, formatPriceRange, formatRelativeDate, formatRelativeTime, getCentsInDollarString, getCheckoutAPI, getCurrencySymbol, isFuture, isNegativeAmount, isNotFoundError, isPast, isRateLimitError, isUnauthorizedError, isValidationError, isZeroAmount, openCheckout, parseDate, portalKeys, resolveApiUrl, resolveApiUrlFromToken, resolveAppUrl, resolveAppUrlFromToken, subscriptionKeys, useAddPaymentMethod, useAvailablePlans, useBillingOS, useCancelPortalSubscription, useCancelSubscription, useChangePlan, useCheckEntitlement, useCheckout, useConfirmCheckout, useCreateCheckout, useCreateSubscription, useEntitlements, useFeature, useFeatureEntitlements, useFeatureGate, useHasFeature, useIsApproachingLimit, usePortalData, usePreviewPlanChange, useProducts as usePricingTableProducts, useProducts$1 as useProducts, useReactivatePortalSubscription, useReactivateSubscription, useRemovePaymentMethod, useRetryInvoice, useSessionToken, useSetDefaultPaymentMethod, useSetupIntent, useSubscription, useSubscriptionPreview, useSubscriptions, useTrackUsage, useUpdateCustomerBilling, useUpdatePortalSubscription, useUpdateSubscription, useUsageCheck, useUsageMetrics };