evaldoc 1.0.0

package/functions/src/payment.js

@@ -0,0 +1,830 @@
+// Payment processing functions with Stripe Connect
+const admin = require('firebase-admin');
+const { stripe } = require('./stripe-config');
+
+/**
+ * Firestore collections for Stripe Connect payment system:
+ *
+ * 1. providers collection - add Stripe Connect fields:
+ *    - pricingModel: 'free' | 'subscription' | 'per-chat' | 'hybrid'
+ *    - subscriptionPrice: number (monthly price in USD)
+ *    - perChatPrice: number (price per conversation in USD)
+ *    - paymentEnabled: boolean
+ *    - currency: string (default 'usd')
+ *    - stripeAccountId: string (Stripe Connect account)
+ *    - stripeOnboardingStatus: 'NOT_STARTED' | 'PENDING' | 'COMPLETE'
+ *    - chargesEnabled: boolean
+ *    - payoutsEnabled: boolean
+ *    - stripeProductId: string
+ *    - stripePriceIds: { day?: string, week?: string, month?: string }
+ *
+ * 2. patients collection (root):
+ *    - stripeCustomerId: string
+ *    - createdAt: timestamp
+ *    - updatedAt: timestamp
+ *
+ * 3. transactions collection (root):
+ *    - providerId: string
+ *    - patientId: string (session ID)
+ *    - conversationId: string (optional)
+ *    - amount: number (in cents)
+ *    - currency: string
+ *    - status: 'pending' | 'succeeded' | 'failed' | 'refunded'
+ *    - paymentMethod: string
+ *    - stripePaymentIntentId: string
+ *    - metadata: object
+ *    - createdAt: timestamp
+ *    - updatedAt: timestamp
+ *
+ * 4. subscriptions collection (root):
+ *    - providerId: string
+ *    - patientId: string (session ID)
+ *    - status: 'active' | 'canceled' | 'past_due' | 'incomplete'
+ *    - stripeSubscriptionId: string
+ *    - stripeCustomerId: string
+ *    - stripePriceId: string
+ *    - currentPeriodStart: timestamp
+ *    - currentPeriodEnd: timestamp
+ *    - cancelAtPeriodEnd: boolean
+ *    - createdAt: timestamp
+ *    - updatedAt: timestamp
+ *
+ * 5. access collection (root) - composite key: {providerId}_{patientId}
+ *    - providerId: string
+ *    - patientId: string
+ *    - status: 'ACTIVE' | 'INACTIVE'
+ *    - stripeSubscriptionId: string
+ *    - currentPeriodEnd: timestamp
+ *    - updatedAt: timestamp
+ */
+
+// ============================================
+// STRIPE CONNECT FUNCTIONS
+// ============================================
+
+/**
+ * Create a Stripe Connect Express account for a provider
+ */
+async function createConnectAccount({ providerId, email, displayName, country = 'US' }) {
+  try {
+    const account = await stripe.accounts.create({
+      type: 'express',
+      country,
+      email,
+      capabilities: {
+        card_payments: { requested: true },
+        transfers: { requested: true },
+      },
+      business_type: 'individual',
+      metadata: {
+        providerId,
+        displayName: displayName || '',
+        platform: 'evaldoc'
+      }
+    });
+
+    const db = admin.firestore();
+    await db.collection('providers').doc(providerId).update({
+      stripeAccountId: account.id,
+      stripeOnboardingStatus: 'PENDING',
+      chargesEnabled: account.charges_enabled,
+      payoutsEnabled: account.payouts_enabled,
+      updatedAt: admin.firestore.FieldValue.serverTimestamp()
+    });
+
+    return {
+      accountId: account.id,
+      onboardingStatus: 'PENDING'
+    };
+  } catch (error) {
+    console.error('Error creating Connect account:', error);
+    throw error;
+  }
+}
+
+/**
+ * Create an onboarding link for Connect account
+ */
+async function createAccountLink({ stripeAccountId, providerId }) {
+  try {
+    const origin = process.env.PLATFORM_URL || 'http://localhost:8080';
+
+    const accountLink = await stripe.accountLinks.create({
+      account: stripeAccountId,
+      refresh_url: `${origin}/app?refresh=true`,
+      return_url: `${origin}/app?onboarding=complete`,
+      type: 'account_onboarding',
+    });
+
+    return {
+      url: accountLink.url,
+      expiresAt: accountLink.expires_at
+    };
+  } catch (error) {
+    console.error('Error creating account link:', error);
+    throw error;
+  }
+}
+
+/**
+ * Check and update Connect account status
+ */
+async function refreshAccountStatus({ providerId, stripeAccountId }) {
+  try {
+    const account = await stripe.accounts.retrieve(stripeAccountId);
+
+    const db = admin.firestore();
+    const updates = {
+      chargesEnabled: account.charges_enabled,
+      payoutsEnabled: account.payouts_enabled,
+      stripeOnboardingStatus: (account.charges_enabled && account.payouts_enabled) ? 'COMPLETE' : 'PENDING',
+      updatedAt: admin.firestore.FieldValue.serverTimestamp()
+    };
+
+    await db.collection('providers').doc(providerId).update(updates);
+
+    return {
+      chargesEnabled: account.charges_enabled,
+      payoutsEnabled: account.payouts_enabled,
+      onboardingComplete: account.charges_enabled && account.payouts_enabled
+    };
+  } catch (error) {
+    console.error('Error refreshing account status:', error);
+    throw error;
+  }
+}
+
+/**
+ * Set provider pricing and create Stripe Products/Prices
+ */
+async function setProviderPricing({
+  providerId,
+  stripeAccountId,
+  currency = 'usd',
+  prices = { month: null, week: null, day: null },
+  displayName
+}) {
+  try {
+    const db = admin.firestore();
+    const providerRef = db.collection('providers').doc(providerId);
+    const provider = (await providerRef.get()).data();
+
+    // Create or retrieve product
+    let productId = provider.stripeProductId;
+
+    if (!productId) {
+      const product = await stripe.products.create({
+        name: `EvalDoc AI Access - ${displayName || 'Provider'}`,
+        description: 'Subscription for AI-powered health consultations',
+      }, {
+        stripeAccount: stripeAccountId
+      });
+      productId = product.id;
+    }
+
+    // Create price objects for each interval
+    const priceIds = {};
+
+    for (const [interval, amount] of Object.entries(prices)) {
+      if (amount && amount > 0) {
+        const price = await stripe.prices.create({
+          product: productId,
+          unit_amount: Math.round(amount * 100), // Convert to cents
+          currency,
+          recurring: {
+            interval: interval === 'month' ? 'month' : interval === 'week' ? 'week' : 'day'
+          },
+        }, {
+          stripeAccount: stripeAccountId
+        });
+
+        priceIds[interval] = price.id;
+      }
+    }
+
+    // Update provider document
+    await providerRef.update({
+      stripeProductId: productId,
+      stripePriceIds: priceIds,
+      currency,
+      subscriptionPrice: prices.month || 0,
+      updatedAt: admin.firestore.FieldValue.serverTimestamp()
+    });
+
+    return { productId, priceIds };
+  } catch (error) {
+    console.error('Error setting provider pricing:', error);
+    throw error;
+  }
+}
+
+// ============================================
+// CHECKOUT & SUBSCRIPTION FUNCTIONS
+// ============================================
+
+/**
+ * Create Stripe Checkout Session for subscription with Connect
+ * Platform takes 25% fee, provider gets 75%
+ */
+async function createCheckoutSession({
+  providerId,
+  patientId,
+  interval = 'month',
+  stripeAccountId,
+  stripePriceId
+}) {
+  try {
+    const db = admin.firestore();
+
+    // Get or create customer
+    let patientDoc = await db.collection('patients').doc(patientId).get();
+    let customerId;
+
+    if (!patientDoc.exists || !patientDoc.data().stripeCustomerId) {
+      // Create Stripe customer
+      const customer = await stripe.customers.create({
+        metadata: {
+          patientId,
+          platform: 'evaldoc'
+        }
+      });
+      customerId = customer.id;
+
+      await db.collection('patients').doc(patientId).set({
+        stripeCustomerId: customerId,
+        createdAt: admin.firestore.FieldValue.serverTimestamp(),
+        updatedAt: admin.firestore.FieldValue.serverTimestamp()
+      }, { merge: true });
+    } else {
+      customerId = patientDoc.data().stripeCustomerId;
+    }
+
+    const origin = process.env.PLATFORM_URL || 'http://localhost:8080';
+
+    // Look up the provider handle for redirect URLs
+    const providerSnap = await db.collection('providers').doc(providerId).get();
+    const handle = providerSnap.exists ? providerSnap.data().handle : '';
+
+    // Create checkout session with Connect
+    // Using application_fee_percent to take 25% platform fee
+    const session = await stripe.checkout.sessions.create({
+      mode: 'subscription',
+      customer: customerId,
+      line_items: [{
+        price: stripePriceId,
+        quantity: 1,
+      }],
+      success_url: `${origin}/${handle}?payment=success&session_id={CHECKOUT_SESSION_ID}`,
+      cancel_url: `${origin}/${handle}?payment=cancelled`,
+      metadata: {
+        providerId,
+        patientId,
+        interval
+      },
+      subscription_data: {
+        application_fee_percent: 25, // Platform takes 25%
+        metadata: {
+          providerId,
+          patientId
+        }
+      }
+    }, {
+      stripeAccount: stripeAccountId // Connect account
+    });
+
+    return {
+      sessionId: session.id,
+      url: session.url
+    };
+  } catch (error) {
+    console.error('Error creating checkout session:', error);
+    throw error;
+  }
+}
+
+/**
+ * Create a payment intent for per-chat payment (with Connect)
+ */
+async function createPaymentIntent({ providerId, patientId, amount, currency = 'usd', metadata = {}, stripeAccountId }) {
+  try {
+    const amountInCents = Math.round(amount * 100);
+    const applicationFee = Math.round(amountInCents * 0.25); // 25% platform fee
+
+    const paymentIntentParams = {
+      amount: amountInCents,
+      currency,
+      metadata: {
+        providerId,
+        patientId,
+        ...metadata
+      },
+      automatic_payment_methods: {
+        enabled: true,
+      },
+    };
+
+    // Route payment through Connect account with 25% platform fee
+    const createOptions = {};
+    if (stripeAccountId) {
+      paymentIntentParams.application_fee_amount = applicationFee;
+      createOptions.stripeAccount = stripeAccountId;
+    }
+
+    const paymentIntent = await stripe.paymentIntents.create(
+      paymentIntentParams,
+      createOptions
+    );
+
+    // Save transaction record
+    const db = admin.firestore();
+    await db.collection('transactions').add({
+      providerId,
+      patientId,
+      conversationId: metadata.conversationId || null,
+      amount: Math.round(amount * 100),
+      currency,
+      status: 'pending',
+      paymentMethod: 'card',
+      stripePaymentIntentId: paymentIntent.id,
+      metadata,
+      createdAt: admin.firestore.FieldValue.serverTimestamp(),
+      updatedAt: admin.firestore.FieldValue.serverTimestamp()
+    });
+
+    return {
+      clientSecret: paymentIntent.client_secret,
+      paymentIntentId: paymentIntent.id
+    };
+  } catch (error) {
+    console.error('Error creating payment intent:', error);
+    throw error;
+  }
+}
+
+/**
+ * Create a subscription for recurring payments
+ */
+async function createSubscription({ providerId, patientId, priceAmount, currency = 'usd' }) {
+  try {
+    // Create or retrieve customer
+    const db = admin.firestore();
+    const existingSubSnapshot = await db
+      .collection('subscriptions')
+      .where('providerId', '==', providerId)
+      .where('patientId', '==', patientId)
+      .where('status', 'in', ['active', 'past_due'])
+      .limit(1)
+      .get();
+
+    if (!existingSubSnapshot.empty) {
+      throw new Error('Active subscription already exists');
+    }
+
+    // Create Stripe customer
+    const customer = await stripe.customers.create({
+      metadata: {
+        providerId,
+        patientId
+      }
+    });
+
+    // Create price object
+    const price = await stripe.prices.create({
+      unit_amount: Math.round(priceAmount * 100),
+      currency,
+      recurring: { interval: 'month' },
+      product_data: {
+        name: `Subscription to Provider ${providerId}`,
+      },
+    });
+
+    // Create subscription
+    const subscription = await stripe.subscriptions.create({
+      customer: customer.id,
+      items: [{ price: price.id }],
+      payment_behavior: 'default_incomplete',
+      payment_settings: { save_default_payment_method: 'on_subscription' },
+      expand: ['latest_invoice.payment_intent'],
+      metadata: {
+        providerId,
+        patientId
+      }
+    });
+
+    // Save subscription record
+    await db.collection('subscriptions').add({
+      providerId,
+      patientId,
+      status: subscription.status,
+      stripeSubscriptionId: subscription.id,
+      stripeCustomerId: customer.id,
+      stripePriceId: price.id,
+      currentPeriodStart: admin.firestore.Timestamp.fromDate(
+        new Date(subscription.current_period_start * 1000)
+      ),
+      currentPeriodEnd: admin.firestore.Timestamp.fromDate(
+        new Date(subscription.current_period_end * 1000)
+      ),
+      cancelAtPeriodEnd: false,
+      createdAt: admin.firestore.FieldValue.serverTimestamp(),
+      updatedAt: admin.firestore.FieldValue.serverTimestamp()
+    });
+
+    return {
+      subscriptionId: subscription.id,
+      clientSecret: subscription.latest_invoice.payment_intent.client_secret
+    };
+  } catch (error) {
+    console.error('Error creating subscription:', error);
+    throw error;
+  }
+}
+
+/**
+ * Cancel a subscription
+ */
+async function cancelSubscription({ subscriptionId, cancelAtPeriodEnd = true }) {
+  try {
+    const subscription = await stripe.subscriptions.update(subscriptionId, {
+      cancel_at_period_end: cancelAtPeriodEnd
+    });
+
+    // Update Firestore record
+    const db = admin.firestore();
+    const snapshot = await db
+      .collection('subscriptions')
+      .where('stripeSubscriptionId', '==', subscriptionId)
+      .limit(1)
+      .get();
+
+    if (!snapshot.empty) {
+      await snapshot.docs[0].ref.update({
+        cancelAtPeriodEnd,
+        status: subscription.status,
+        updatedAt: admin.firestore.FieldValue.serverTimestamp()
+      });
+    }
+
+    return subscription;
+  } catch (error) {
+    console.error('Error canceling subscription:', error);
+    throw error;
+  }
+}
+
+/**
+ * Check if patient has active subscription or has paid for conversation
+ */
+async function checkPaymentAccess({ providerId, patientId, conversationId }) {
+  const db = admin.firestore();
+
+  // Fast O(1) lookup via the access collection (maintained by webhooks)
+  const accessId = `${providerId}_${patientId}`;
+  const accessDoc = await db.collection('access').doc(accessId).get();
+
+  if (accessDoc.exists) {
+    const access = accessDoc.data();
+    if (access.status === 'ACTIVE') {
+      return { hasAccess: true, type: 'subscription' };
+    }
+  }
+
+  // Fallback: check subscriptions collection directly (for non-Connect subscriptions)
+  const subSnapshot = await db
+    .collection('subscriptions')
+    .where('providerId', '==', providerId)
+    .where('patientId', '==', patientId)
+    .where('status', 'in', ['active', 'past_due'])
+    .limit(1)
+    .get();
+
+  if (!subSnapshot.empty) {
+    const sub = subSnapshot.docs[0].data();
+    const now = admin.firestore.Timestamp.now();
+    if (sub.currentPeriodEnd && sub.currentPeriodEnd.toMillis() > now.toMillis()) {
+      return { hasAccess: true, type: 'subscription' };
+    }
+  }
+
+  // Check for per-chat payment
+  if (conversationId) {
+    const txSnapshot = await db
+      .collection('transactions')
+      .where('providerId', '==', providerId)
+      .where('patientId', '==', patientId)
+      .where('conversationId', '==', conversationId)
+      .where('status', '==', 'succeeded')
+      .limit(1)
+      .get();
+
+    if (!txSnapshot.empty) {
+      return { hasAccess: true, type: 'per-chat' };
+    }
+  }
+
+  return { hasAccess: false, type: null };
+}
+
+/**
+ * Get revenue analytics for provider
+ */
+async function getRevenueAnalytics({ providerId, startDate, endDate }) {
+  const db = admin.firestore();
+
+  let query = db
+    .collection('transactions')
+    .where('providerId', '==', providerId)
+    .where('status', '==', 'succeeded');
+
+  if (startDate) {
+    query = query.where('createdAt', '>=', startDate);
+  }
+  if (endDate) {
+    query = query.where('createdAt', '<=', endDate);
+  }
+
+  const snapshot = await query.get();
+
+  let totalRevenue = 0;
+  let transactionCount = 0;
+  const revenueByDay = {};
+
+  snapshot.forEach(doc => {
+    const data = doc.data();
+    totalRevenue += data.amount;
+    transactionCount++;
+
+    // Group by day
+    const date = data.createdAt.toDate().toISOString().split('T')[0];
+    if (!revenueByDay[date]) {
+      revenueByDay[date] = { revenue: 0, count: 0 };
+    }
+    revenueByDay[date].revenue += data.amount;
+    revenueByDay[date].count++;
+  });
+
+  // Get active subscriptions
+  const subSnapshot = await db
+    .collection('subscriptions')
+    .where('providerId', '==', providerId)
+    .where('status', '==', 'active')
+    .get();
+
+  return {
+    totalRevenue: totalRevenue / 100, // Convert from cents to dollars
+    transactionCount,
+    revenueByDay,
+    activeSubscriptions: subSnapshot.size,
+    currency: 'USD'
+  };
+}
+
+/**
+ * Handle Stripe webhook events (including Connect events)
+ */
+async function handleStripeWebhook(event) {
+  const db = admin.firestore();
+
+  try {
+    switch (event.type) {
+      // Connect account events
+      case 'account.updated': {
+        const account = event.data.object;
+        const providerId = account.metadata?.providerId;
+
+        if (providerId) {
+          await db.collection('providers').doc(providerId).update({
+            chargesEnabled: account.charges_enabled,
+            payoutsEnabled: account.payouts_enabled,
+            stripeOnboardingStatus: (account.charges_enabled && account.payouts_enabled) ? 'COMPLETE' : 'PENDING',
+            updatedAt: admin.firestore.FieldValue.serverTimestamp()
+          });
+        }
+        break;
+      }
+
+      // Checkout session completed
+      case 'checkout.session.completed': {
+        const session = event.data.object;
+        const { providerId, patientId } = session.metadata;
+
+        if (session.mode === 'subscription' && session.subscription) {
+          // Subscription will be handled by customer.subscription.created event
+          console.log('Checkout session completed for subscription:', session.subscription);
+        }
+        break;
+      }
+
+      // Subscription events
+      case 'customer.subscription.created':
+      case 'customer.subscription.updated': {
+        const subscription = event.data.object;
+        const { providerId, patientId } = subscription.metadata;
+
+        if (!providerId || !patientId) {
+          console.warn('Subscription missing metadata:', subscription.id);
+          break;
+        }
+
+        // Validate subscription has price items
+        const stripePriceId = subscription.items?.data?.[0]?.price?.id;
+        if (!stripePriceId) {
+          console.warn('Subscription missing price items:', subscription.id);
+          break;
+        }
+
+        const subData = {
+          providerId,
+          patientId,
+          stripeSubscriptionId: subscription.id,
+          stripeCustomerId: subscription.customer,
+          stripePriceId,
+          status: subscription.status,
+          currentPeriodStart: admin.firestore.Timestamp.fromDate(
+            new Date(subscription.current_period_start * 1000)
+          ),
+          currentPeriodEnd: admin.firestore.Timestamp.fromDate(
+            new Date(subscription.current_period_end * 1000)
+          ),
+          cancelAtPeriodEnd: subscription.cancel_at_period_end,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp()
+        };
+
+        // Use stripeSubscriptionId as doc ID to prevent duplicates on webhook retries
+        const subDocRef = db.collection('subscriptions').doc(subscription.id);
+        const subDoc = await subDocRef.get();
+
+        if (!subDoc.exists) {
+          subData.createdAt = admin.firestore.FieldValue.serverTimestamp();
+        }
+        await subDocRef.set(subData, { merge: true });
+
+        // Update access control
+        const accessId = `${providerId}_${patientId}`;
+        const isActive = subscription.status === 'active';
+
+        await db.collection('access').doc(accessId).set({
+          providerId,
+          patientId,
+          status: isActive ? 'ACTIVE' : 'INACTIVE',
+          stripeSubscriptionId: subscription.id,
+          currentPeriodEnd: admin.firestore.Timestamp.fromDate(
+            new Date(subscription.current_period_end * 1000)
+          ),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp()
+        }, { merge: true });
+
+        break;
+      }
+
+      case 'customer.subscription.deleted': {
+        const subscription = event.data.object;
+        const { providerId, patientId } = subscription.metadata;
+
+        if (!providerId || !patientId) break;
+
+        // Mark subscription as canceled
+        const subSnapshot = await db
+          .collection('subscriptions')
+          .where('stripeSubscriptionId', '==', subscription.id)
+          .limit(1)
+          .get();
+
+        if (!subSnapshot.empty) {
+          await subSnapshot.docs[0].ref.update({
+            status: 'canceled',
+            updatedAt: admin.firestore.FieldValue.serverTimestamp()
+          });
+        }
+
+        // Revoke access (use set+merge in case access doc doesn't exist yet)
+        const accessId = `${providerId}_${patientId}`;
+        await db.collection('access').doc(accessId).set({
+          providerId,
+          patientId,
+          status: 'INACTIVE',
+          stripeSubscriptionId: subscription.id,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp()
+        }, { merge: true });
+
+        break;
+      }
+
+      // Invoice events
+      case 'invoice.payment_succeeded': {
+        const invoice = event.data.object;
+        const subscription = invoice.subscription;
+
+        if (subscription) {
+          // Payment successful - ensure access is active
+          const subDoc = await db
+            .collection('subscriptions')
+            .where('stripeSubscriptionId', '==', subscription)
+            .limit(1)
+            .get();
+
+          if (!subDoc.empty) {
+            const subData = subDoc.docs[0].data();
+            const accessId = `${subData.providerId}_${subData.patientId}`;
+
+            await db.collection('access').doc(accessId).set({
+              providerId: subData.providerId,
+              patientId: subData.patientId,
+              status: 'ACTIVE',
+              stripeSubscriptionId: subscription,
+              currentPeriodEnd: subData.currentPeriodEnd,
+              updatedAt: admin.firestore.FieldValue.serverTimestamp()
+            }, { merge: true });
+          }
+        }
+        break;
+      }
+
+      case 'invoice.payment_failed': {
+        const invoice = event.data.object;
+        const subscription = invoice.subscription;
+
+        if (subscription) {
+          // Payment failed - revoke access immediately
+          const subDoc = await db
+            .collection('subscriptions')
+            .where('stripeSubscriptionId', '==', subscription)
+            .limit(1)
+            .get();
+
+          if (!subDoc.empty) {
+            const subData = subDoc.docs[0].data();
+            const accessId = `${subData.providerId}_${subData.patientId}`;
+
+            await db.collection('access').doc(accessId).set({
+              providerId: subData.providerId,
+              patientId: subData.patientId,
+              status: 'INACTIVE',
+              updatedAt: admin.firestore.FieldValue.serverTimestamp()
+            }, { merge: true });
+          }
+        }
+        break;
+      }
+
+      // Payment intent events (for per-chat payments)
+      case 'payment_intent.succeeded': {
+        const paymentIntent = event.data.object;
+        const snapshot = await db
+          .collection('transactions')
+          .where('stripePaymentIntentId', '==', paymentIntent.id)
+          .limit(1)
+          .get();
+
+        if (!snapshot.empty) {
+          await snapshot.docs[0].ref.update({
+            status: 'succeeded',
+            updatedAt: admin.firestore.FieldValue.serverTimestamp()
+          });
+        }
+        break;
+      }
+
+      case 'payment_intent.payment_failed': {
+        const paymentIntent = event.data.object;
+        const snapshot = await db
+          .collection('transactions')
+          .where('stripePaymentIntentId', '==', paymentIntent.id)
+          .limit(1)
+          .get();
+
+        if (!snapshot.empty) {
+          await snapshot.docs[0].ref.update({
+            status: 'failed',
+            updatedAt: admin.firestore.FieldValue.serverTimestamp()
+          });
+        }
+        break;
+      }
+
+      default:
+        console.log(`Unhandled event type: ${event.type}`);
+    }
+  } catch (error) {
+    console.error('Error handling webhook:', error);
+    throw error;
+  }
+}
+
+module.exports = {
+  // Stripe Connect functions
+  createConnectAccount,
+  createAccountLink,
+  refreshAccountStatus,
+  setProviderPricing,
+  // Checkout & subscriptions
+  createCheckoutSession,
+  createPaymentIntent,
+  createSubscription,
+  cancelSubscription,
+  checkPaymentAccess,
+  // Analytics
+  getRevenueAnalytics,
+  // Webhooks
+  handleStripeWebhook
+};