@solvapay/react 1.0.0-preview.1 → 1.0.0-preview.11

package/dist/index.d.cts

@@ -1,84 +1,703 @@
-import React from 'react';
-import { Stripe } from '@stripe/stripe-js';
+import React$1 from 'react';
+import { PaymentIntent, Stripe } from '@stripe/stripe-js';
+import { ProcessPaymentResult } from '@solvapay/server';
+import { AuthAdapter } from './adapters/auth.cjs';
+export { defaultAuthAdapter } from './adapters/auth.cjs';
 
+/**
+ * TypeScript type definitions for @solvapay/react
+ */
+
+interface SubscriptionInfo {
+    reference: string;
+    planName: string;
+    agentName: string;
+    status: string;
+    startDate: string;
+    endDate?: string;
+    cancelledAt?: string;
+    cancellationReason?: string;
+    amount?: number;
+}
+interface CustomerSubscriptionData {
+    customerRef?: string;
+    email?: string;
+    name?: string;
+    subscriptions: SubscriptionInfo[];
+}
+interface PaymentIntentResult {
+    clientSecret: string;
+    publishableKey: string;
+    accountId?: string;
+    customerRef?: string;
+}
+interface SubscriptionStatus {
+    loading: boolean;
+    customerRef?: string;
+    email?: string;
+    name?: string;
+    subscriptions: SubscriptionInfo[];
+    hasPlan: (planName: string) => boolean;
+    /**
+     * Primary active subscription (paid or free) - most recent subscription with status === 'active'
+     * Backend keeps subscriptions as 'active' until expiration, even when cancelled.
+     * null if no active subscription exists
+     */
+    activeSubscription: SubscriptionInfo | null;
+    /**
+     * Check if user has any active paid subscription (amount > 0)
+     * Checks subscriptions with status === 'active'.
+     * Backend keeps subscriptions as 'active' until expiration, even when cancelled.
+     */
+    hasPaidSubscription: boolean;
+    /**
+     * Most recent active paid subscription (sorted by startDate)
+     * Returns subscription with status === 'active' and amount > 0.
+     * null if no active paid subscription exists
+     */
+    activePaidSubscription: SubscriptionInfo | null;
+}
+/**
+ * SolvaPay Provider Configuration
+ * Sensible defaults for minimal code, but fully customizable
+ */
+interface SolvaPayConfig {
+    /**
+     * API route configuration
+     * Defaults to standard Next.js API routes
+     */
+    api?: {
+        checkSubscription?: string;
+        createPayment?: string;
+        processPayment?: string;
+    };
+    /**
+     * Authentication configuration
+     * Uses adapter pattern for flexible auth provider support
+     */
+    auth?: {
+        /**
+         * Auth adapter instance
+         * Default: checks localStorage for 'auth_token' key
+         *
+         * @example
+         * ```tsx
+         * import { createSupabaseAuthAdapter } from '@solvapay/react-supabase';
+         *
+         * <SolvaPayProvider
+         *   config={{
+         *     auth: {
+         *       adapter: createSupabaseAuthAdapter({
+         *         supabaseUrl: process.env.NEXT_PUBLIC_SUPABASE_URL!,
+         *         supabaseAnonKey: process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+         *       })
+         *     }
+         *   }}
+         * >
+         * ```
+         */
+        adapter?: AuthAdapter;
+        /**
+         * @deprecated Use `adapter` instead. Will be removed in a future version.
+         * Function to get auth token
+         */
+        getToken?: () => Promise<string | null>;
+        /**
+         * @deprecated Use `adapter` instead. Will be removed in a future version.
+         * Function to get user ID (for cache key)
+         */
+        getUserId?: () => Promise<string | null>;
+    };
+    /**
+     * Custom fetch implementation
+     * Default: uses global fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Request headers to include in all API calls
+     * Default: empty
+     */
+    headers?: HeadersInit | (() => Promise<HeadersInit>);
+    /**
+     * Custom error handler
+     * Default: logs to console
+     */
+    onError?: (error: Error, context: string) => void;
+}
+interface SolvaPayContextValue {
+    subscription: SubscriptionStatus;
+    refetchSubscription: () => Promise<void>;
+    createPayment: (params: {
+        planRef: string;
+        agentRef?: string;
+    }) => Promise<PaymentIntentResult>;
+    processPayment?: (params: {
+        paymentIntentId: string;
+        agentRef: string;
+        planRef?: string;
+    }) => Promise<ProcessPaymentResult>;
+    customerRef?: string;
+    updateCustomerRef?: (newCustomerRef: string) => void;
+}
 interface SolvaPayProviderProps {
+    /**
+     * Configuration object with sensible defaults
+     * If not provided, uses standard Next.js API routes
+     */
+    config?: SolvaPayConfig;
+    /**
+     * Custom API functions (override config defaults)
+     * Use only if you need custom logic beyond standard API routes
+     */
+    createPayment?: (params: {
+        planRef: string;
+        agentRef?: string;
+    }) => Promise<PaymentIntentResult>;
+    checkSubscription?: () => Promise<CustomerSubscriptionData>;
+    processPayment?: (params: {
+        paymentIntentId: string;
+        agentRef: string;
+        planRef?: string;
+    }) => Promise<ProcessPaymentResult>;
     children: React.ReactNode;
-    amount?: number;
+}
+interface PlanBadgeProps {
+    children?: (props: {
+        subscriptions: SubscriptionInfo[];
+        loading: boolean;
+        displayPlan: string | null;
+        shouldShow: boolean;
+    }) => React.ReactNode;
+    as?: React.ElementType;
+    className?: string | ((props: {
+        subscriptions: SubscriptionInfo[];
+    }) => string);
+}
+interface SubscriptionGateProps {
+    requirePlan?: string;
+    children: (props: {
+        hasAccess: boolean;
+        subscriptions: SubscriptionInfo[];
+        loading: boolean;
+    }) => React.ReactNode;
+}
+/**
+ * Error type for payment operations
+ */
+interface PaymentError extends Error {
+    code?: string;
+    type?: string;
+}
+/**
+ * Plan interface for subscription plans
+ */
+interface Plan {
+    reference: string;
+    name: string;
+    description?: string;
+    price?: number;
     currency?: string;
+    interval?: string;
+    features?: string[];
+    isFreeTier?: boolean;
+    metadata?: Record<string, any>;
+}
+/**
+ * Options for usePlans hook
+ */
+interface UsePlansOptions {
+    /**
+     * Fetcher function to retrieve plans
+     */
+    fetcher: (agentRef: string) => Promise<Plan[]>;
+    /**
+     * Agent reference to fetch plans for
+     */
+    agentRef?: string;
+    /**
+     * Optional filter function to filter plans
+     */
+    filter?: (plan: Plan) => boolean;
+    /**
+     * Optional sort function to sort plans
+     */
+    sortBy?: (a: Plan, b: Plan) => number;
+    /**
+     * Auto-select first paid plan on load
+     */
+    autoSelectFirstPaid?: boolean;
+}
+/**
+ * Return type for usePlans hook
+ */
+interface UsePlansReturn {
+    plans: Plan[];
+    loading: boolean;
+    error: Error | null;
+    selectedPlanIndex: number;
+    selectedPlan: Plan | null;
+    setSelectedPlanIndex: (index: number) => void;
+    selectPlan: (planRef: string) => void;
+    refetch: () => Promise<void>;
+}
+/**
+ * Props for headless PlanSelector component
+ */
+interface PlanSelectorProps {
+    /**
+     * Agent reference to fetch plans for
+     */
+    agentRef?: string;
+    /**
+     * Fetcher function to retrieve plans
+     */
+    fetcher: (agentRef: string) => Promise<Plan[]>;
+    /**
+     * Optional filter function
+     */
+    filter?: (plan: Plan) => boolean;
+    /**
+     * Optional sort function
+     */
+    sortBy?: (a: Plan, b: Plan) => number;
+    /**
+     * Auto-select first paid plan on load
+     */
+    autoSelectFirstPaid?: boolean;
+    /**
+     * Render prop function
+     */
+    children: (props: UsePlansReturn & {
+        subscriptions: SubscriptionInfo[];
+        isPaidPlan: (planName: string) => boolean;
+        isCurrentPlan: (planName: string) => boolean;
+    }) => React.ReactNode;
+}
+/**
+ * Return type for useSubscriptionStatus hook
+ *
+ * Provides advanced subscription status helpers and utilities.
+ * Focuses on cancelled subscription logic and date formatting.
+ * For basic subscription data and paid status, use useSubscription() instead.
+ */
+interface SubscriptionStatusReturn {
+    /**
+     * Most recent cancelled paid subscription (sorted by startDate)
+     * null if no cancelled paid subscription exists
+     */
+    cancelledSubscription: SubscriptionInfo | null;
+    /**
+     * Whether to show cancelled subscription notice
+     * true if cancelledSubscription exists
+     */
+    shouldShowCancelledNotice: boolean;
+    /**
+     * Format a date string to locale format (e.g., "January 15, 2024")
+     * Returns null if dateString is not provided
+     */
+    formatDate: (dateString?: string) => string | null;
+    /**
+     * Calculate days until expiration date
+     * Returns null if endDate is not provided, otherwise returns days (0 or positive)
+     */
+    getDaysUntilExpiration: (endDate?: string) => number | null;
+}
+/**
+ * Payment form props - simplified and minimal
+ */
+interface PaymentFormProps {
+    /**
+     * Plan reference to checkout. PaymentForm handles the entire checkout flow internally
+     * including Stripe initialization and payment intent creation.
+     */
     planRef: string;
-    agentRef: string;
-    apiBaseUrl?: string;
-    onPaymentReady?: (stripe: Stripe | null, clientSecret: string) => void;
+    /**
+     * Agent reference. Required for processing payment after confirmation.
+     */
+    agentRef?: string;
+    /**
+     * Callback when payment succeeds
+     */
+    onSuccess?: (paymentIntent: PaymentIntent) => void;
+    /**
+     * Callback when payment fails
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Return URL after payment completion. Defaults to current page URL if not provided.
+     */
+    returnUrl?: string;
+    /**
+     * Text for the submit button. Defaults to "Pay Now"
+     */
+    submitButtonText?: string;
+    /**
+     * Optional className for the form container
+     */
+    className?: string;
+    /**
+     * Optional className for the submit button
+     */
+    buttonClassName?: string;
 }
+
 /**
- * SolvaPay Payment Provider Component
+ * SolvaPay Provider - Headless Context Provider
+ *
+ * Provides subscription state and payment methods to child components.
+ * Supports zero-config with sensible defaults, or full customization.
  *
- * Wraps children with Stripe Elements context after initializing a payment intent
- * via the backend API. This component handles the secure payment flow:
+ * @example
+ * ```tsx
+ * // Zero config (uses defaults)
+ * <SolvaPayProvider>
+ *   <App />
+ * </SolvaPayProvider>
  *
- * 1. Calls backend API route to create payment intent (backend uses secret key)
- * 2. Backend returns clientSecret and publishableKey from Stripe
- * 3. Initializes Stripe.js with publishableKey
- * 4. Wraps children in Stripe Elements provider
+ * // Custom API routes
+ * <SolvaPayProvider
+ *   config={{
+ *     api: {
+ *       checkSubscription: '/custom/api/subscription',
+ *       createPayment: '/custom/api/payment'
+ *     }
+ *   }}
+ * >
+ *   <App />
+ * </SolvaPayProvider>
+ *
+ * // Fully custom
+ * <SolvaPayProvider
+ *   checkSubscription={async () => {
+ *     return await myCustomAPI.checkSubscription();
+ *   }}
+ *   createPayment={async ({ planRef, agentRef }) => {
+ *     return await myCustomAPI.createPayment(planRef, agentRef);
+ *   }}
+ * >
+ *   <App />
+ * </SolvaPayProvider>
+ * ```
+ */
+declare const SolvaPayProvider: React$1.FC<SolvaPayProviderProps>;
+
+/**
+ * SolvaPay Payment Form Component
+ *
+ * A simplified, minimal payment form that handles the checkout flow.
+ * Automatically initializes Stripe and displays the payment form.
  *
  * @example
  * ```tsx
- * // In your Next.js page
- * import { SolvaPayProvider, PaymentForm } from '@solvapay/react';
+ * import { PaymentForm } from '@solvapay/react';
  *
- * export default function CheckoutPage() {
- *   return (
- *     <SolvaPayProvider
- *       amount={999}
- *       currency="USD"
- *       planRef="pln_abc123"
- *       agentRef="agt_xyz789"
- *       onPaymentReady={(stripe, clientSecret) => {
- *         console.log('Payment ready!');
- *       }}
- *     >
- *       <PaymentForm />
- *     </SolvaPayProvider>
- *   );
- * }
+ * <PaymentForm
+ *   planRef="pro_plan"
+ *   agentRef="agent_123"
+ *   onSuccess={(paymentIntent) => {
+ *     console.log('Payment successful!');
+ *   }}
+ *   onError={(error) => {
+ *     console.error('Payment failed:', error);
+ *   }}
+ * />
  * ```
  */
-declare const SolvaPayProvider: React.FC<SolvaPayProviderProps>;
+declare const PaymentForm: React$1.FC<PaymentFormProps>;
 
-interface PaymentFormProps {
-    onSuccess?: (paymentIntent: any) => void;
+/**
+ * Headless Plan Badge Component
+ *
+ * Displays subscription status with complete styling control.
+ * Supports render props, custom components, or className patterns.
+ *
+ * Prevents flickering by hiding the badge during initial load and when no subscription exists.
+ * Shows the badge once loading completes AND an active subscription exists (paid or free).
+ * Badge only updates when the plan name actually changes (prevents unnecessary re-renders).
+ *
+ * Displays the primary active subscription (paid or free) to show current plan status.
+ *
+ * @example
+ * ```tsx
+ * // Render prop pattern
+ * <PlanBadge>
+ *   {({ subscriptions, loading, displayPlan, shouldShow }) => (
+ *     shouldShow ? (
+ *       <div>{displayPlan}</div>
+ *     ) : null
+ *   )}
+ * </PlanBadge>
+ *
+ * //ClassName pattern
+ * <PlanBadge className="badge badge-primary" />
+ * ```
+ */
+declare const PlanBadge: React$1.FC<PlanBadgeProps>;
+
+/**
+ * Headless Subscription Gate Component
+ *
+ * Controls access to content based on subscription status.
+ * Uses render props to give developers full control over locked/unlocked states.
+ *
+ * @example
+ * ```tsx
+ * <SubscriptionGate requirePlan="Pro Plan">
+ *   {({ hasAccess, loading }) => {
+ *     if (loading) return <Skeleton />;
+ *     if (!hasAccess) return <Paywall />;
+ *     return <PremiumContent />;
+ *   }}
+ * </SubscriptionGate>
+ * ```
+ */
+declare const SubscriptionGate: React$1.FC<SubscriptionGateProps>;
+
+/**
+ * Headless Plan Selector Component
+ *
+ * Provides plan selection logic with complete styling control via render props.
+ * Integrates plan fetching, subscription status, and selection state management.
+ *
+ * Features:
+ * - Fetches and manages plans
+ * - Tracks selected plan
+ * - Provides helpers for checking if plan is current/paid
+ * - Integrates with subscription context
+ *
+ * @example
+ * ```tsx
+ * <PlanSelector
+ *   agentRef="agent_123"
+ *   fetcher={async (agentRef) => {
+ *     const res = await fetch(`/api/list-plans?agentRef=${agentRef}`);
+ *     const data = await res.json();
+ *     return data.plans;
+ *   }}
+ *   sortBy={(a, b) => (a.price || 0) - (b.price || 0)}
+ *   autoSelectFirstPaid
+ * >
+ *   {({ plans, selectedPlan, setSelectedPlanIndex, loading, isPaidPlan, isCurrentPlan }) => (
+ *     <div>
+ *       {loading ? (
+ *         <div>Loading plans...</div>
+ *       ) : (
+ *         plans.map((plan, index) => (
+ *           <button
+ *             key={plan.reference}
+ *             onClick={() => setSelectedPlanIndex(index)}
+ *             disabled={!isPaidPlan(plan.name)}
+ *           >
+ *             {plan.name} - ${plan.price}
+ *             {isCurrentPlan(plan.name) && ' (Current)'}
+ *           </button>
+ *         ))
+ *       )}
+ *     </div>
+ *   )}
+ * </PlanSelector>
+ * ```
+ */
+declare const PlanSelector: React$1.FC<PlanSelectorProps>;
+
+/**
+ * SVG-based spinner component using CSS animations
+ * Uses the same spinner design as the rest of the site
+ */
+declare const Spinner: React$1.FC<{
+    className?: string;
+    size?: 'sm' | 'md' | 'lg';
+}>;
+
+interface StripePaymentFormWrapperProps {
+    onSuccess?: (paymentIntent: any) => void | Promise<void>;
     onError?: (error: Error) => void;
     returnUrl?: string;
     submitButtonText?: string;
-    className?: string;
+    buttonClassName?: string;
+    clientSecret: string;
 }
 /**
- * SolvaPay Payment Form Component
- *
- * Renders a payment form using Stripe's PaymentElement for secure card input.
- * This component must be wrapped in a SolvaPayProvider to work properly.
+ * Stripe Payment Form Wrapper Component
+ * Renders inside Stripe Elements context and handles the payment flow
+ * All hooks are called unconditionally to comply with React Rules of Hooks
+ */
+declare const StripePaymentFormWrapper: React$1.FC<StripePaymentFormWrapperProps>;
+
+/**
+ * Hook to access subscription status
+ * Returns the current subscription state and a refetch function
+ */
+declare function useSubscription(): SubscriptionStatus & {
+    refetch: () => Promise<void>;
+};
+
+/**
+ * Customer information interface
+ */
+interface CustomerInfo {
+    /**
+     * Customer reference ID
+     */
+    customerRef?: string;
+    /**
+     * Customer email address
+     */
+    email?: string;
+    /**
+     * Customer name
+     */
+    name?: string;
+    /**
+     * Whether customer data is currently loading
+     */
+    loading: boolean;
+}
+/**
+ * Hook to access customer information
+ * Returns customer data (email, name, customerRef) separate from subscription data
  *
  * @example
  * ```tsx
- * import { SolvaPayProvider, PaymentForm } from '@solvapay/react';
+ * import { useCustomer } from '@solvapay/react';
+ *
+ * function MyComponent() {
+ *   const { email, name, customerRef } = useCustomer();
  *
- * export default function CheckoutPage() {
  *   return (
- *     <SolvaPayProvider amount={999} planRef="pln_abc123">
- *       <PaymentForm
- *         returnUrl={`${window.location.origin}/checkout/success`}
- *         onSuccess={(paymentIntent) => {
- *           console.log('Payment successful!', paymentIntent);
- *         }}
- *         onError={(error) => {
- *           console.error('Payment failed:', error);
- *         }}
- *       />
- *     </SolvaPayProvider>
+ *     <div>
+ *       <p>Email: {email || 'Not provided'}</p>
+ *       <p>Name: {name || 'Not provided'}</p>
+ *     </div>
  *   );
  * }
  * ```
  */
-declare const PaymentForm: React.FC<PaymentFormProps>;
+declare function useCustomer(): CustomerInfo;
+
+interface UseCheckoutReturn {
+    loading: boolean;
+    error: Error | null;
+    stripePromise: Promise<Stripe | null> | null;
+    clientSecret: string | null;
+    startCheckout: () => Promise<void>;
+    reset: () => void;
+}
+/**
+ * Hook to manage checkout flow
+ * Handles payment intent creation and Stripe initialization
+ *
+ * @param planRef - The plan reference to checkout
+ * @param agentRef - Optional agent reference
+ */
+declare function useCheckout(planRef: string, agentRef?: string): UseCheckoutReturn;
+
+/**
+ * Hook to access SolvaPay context
+ * Must be used within a SolvaPayProvider
+ */
+declare function useSolvaPay(): SolvaPayContextValue;
+
+/**
+ * Hook to manage plan fetching and selection
+ *
+ * Provides a reusable way to fetch, filter, sort and select subscription plans.
+ * Handles loading and error states automatically.
+ * Uses a global cache to prevent duplicate fetches when multiple components use the same agentRef.
+ *
+ * @example
+ * ```tsx
+ * const plans = usePlans({
+ *   agentRef: 'agent_123',
+ *   fetcher: async (agentRef) => {
+ *     const res = await fetch(`/api/list-plans?agentRef=${agentRef}`);
+ *     const data = await res.json();
+ *     return data.plans;
+ *   },
+ *   sortBy: (a, b) => (a.price || 0) - (b.price || 0),
+ *   autoSelectFirstPaid: true,
+ * });
+ *
+ * // Use in component
+ * if (plans.loading) return <div>Loading...</div>;
+ * if (plans.error) return <div>Error: {plans.error.message}</div>;
+ * ```
+ */
+declare function usePlans(options: UsePlansOptions): UsePlansReturn;
+
+/**
+ * Hook providing advanced status and helper functions for subscription management
+ *
+ * Focuses on cancelled subscription logic and date formatting utilities.
+ * For basic subscription data and paid status checks, use useSubscription() instead.
+ *
+ * @example
+ * ```tsx
+ * const { cancelledSubscription, shouldShowCancelledNotice, formatDate, getDaysUntilExpiration } = useSubscriptionStatus();
+ *
+ * if (shouldShowCancelledNotice && cancelledSubscription) {
+ *   const formattedDate = formatDate(cancelledSubscription.endDate);
+ *   const daysLeft = getDaysUntilExpiration(cancelledSubscription.endDate);
+ * }
+ * ```
+ */
+declare function useSubscriptionStatus(): SubscriptionStatusReturn;
+
+/**
+ * Subscription utility functions
+ *
+ * Provides shared logic for filtering and prioritizing subscriptions
+ */
+
+/**
+ * Filter subscriptions to only include active ones
+ *
+ * Rules:
+ * - Keep subscriptions with status === 'active'
+ * - Filter out subscriptions with status === 'cancelled', 'expired', 'suspended', 'refunded', etc.
+ *
+ * Note: Backend now keeps subscriptions with status 'active' until expiration,
+ * even when cancelled. Cancellation is tracked via cancelledAt field.
+ */
+declare function filterSubscriptions(subscriptions: SubscriptionInfo[]): SubscriptionInfo[];
+/**
+ * Get active subscriptions
+ *
+ * Returns subscriptions with status === 'active'.
+ * Note: Backend keeps subscriptions as 'active' until expiration, even when cancelled.
+ * Use cancelledAt field to check if a subscription is cancelled.
+ */
+declare function getActiveSubscriptions(subscriptions: SubscriptionInfo[]): SubscriptionInfo[];
+/**
+ * Get cancelled subscriptions with valid endDate (not expired)
+ *
+ * Returns subscriptions with cancelledAt set and status === 'active' that have a future endDate.
+ * Backend keeps cancelled subscriptions as 'active' until expiration.
+ */
+declare function getCancelledSubscriptionsWithEndDate(subscriptions: SubscriptionInfo[]): SubscriptionInfo[];
+/**
+ * Get the most recent subscription by startDate
+ */
+declare function getMostRecentSubscription(subscriptions: SubscriptionInfo[]): SubscriptionInfo | null;
+/**
+ * Get the primary subscription to display
+ *
+ * Prioritization:
+ * 1. Active subscriptions (most recent by startDate)
+ * 2. null if no valid subscriptions
+ *
+ * Note: Backend keeps subscriptions as 'active' until expiration, so we only
+ * need to check for active subscriptions. Cancelled subscriptions are still
+ * active until their endDate.
+ */
+declare function getPrimarySubscription(subscriptions: SubscriptionInfo[]): SubscriptionInfo | null;
+/**
+ * Check if a subscription is paid
+ * Uses subscription amount field: amount > 0 = paid, amount === 0 or undefined = free
+ *
+ * @param sub - Subscription to check
+ * @returns true if subscription is paid (amount > 0)
+ */
+declare function isPaidSubscription(sub: SubscriptionInfo): boolean;
 
-export { PaymentForm, type PaymentFormProps, SolvaPayProvider, type SolvaPayProviderProps };
+export { AuthAdapter, type CustomerInfo, type CustomerSubscriptionData, type PaymentError, PaymentForm, type PaymentFormProps, type PaymentIntentResult, type Plan, PlanBadge, type PlanBadgeProps, PlanSelector, type PlanSelectorProps, type SolvaPayConfig, type SolvaPayContextValue, SolvaPayProvider, type SolvaPayProviderProps, Spinner, StripePaymentFormWrapper, SubscriptionGate, type SubscriptionGateProps, type SubscriptionInfo, type SubscriptionStatus, type SubscriptionStatusReturn, type UsePlansOptions, type UsePlansReturn, filterSubscriptions, getActiveSubscriptions, getCancelledSubscriptionsWithEndDate, getMostRecentSubscription, getPrimarySubscription, isPaidSubscription, useCheckout, useCustomer, usePlans, useSolvaPay, useSubscription, useSubscriptionStatus };