@digilogiclabs/saas-factory-payments 0.1.0

package/dist/native/index.mjs

@@ -0,0 +1,1815 @@
+// src/native/components/CheckoutButton.tsx
+import { useState } from "react";
+import {
+  TouchableOpacity,
+  Text,
+  ActivityIndicator,
+  StyleSheet,
+  Alert
+} from "react-native";
+import { useStripe } from "@stripe/stripe-react-native";
+
+// src/shared/providers/PaymentsProvider.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var PaymentsContext = createContext(
+  void 0
+);
+var usePaymentsConfig = () => {
+  const context = useContext(PaymentsContext);
+  if (!context) {
+    throw new Error("usePaymentsConfig must be used within PaymentsProvider");
+  }
+  return context;
+};
+
+// src/shared/constants.ts
+var CURRENCY_SYMBOLS = {
+  USD: "$",
+  EUR: "\u20AC",
+  GBP: "\xA3",
+  JPY: "\xA5",
+  CAD: "C$",
+  AUD: "A$",
+  CHF: "CHF",
+  CNY: "\xA5",
+  SEK: "kr",
+  NZD: "NZ$"
+};
+var DEFAULT_CURRENCY = "USD";
+var ERROR_MESSAGES = {
+  PROVIDER_NOT_CONFIGURED: "Payments provider is not properly configured",
+  STRIPE_NOT_LOADED: "Stripe has not been loaded yet",
+  INVALID_PRICE_ID: "Invalid price ID provided",
+  INVALID_CUSTOMER_ID: "Invalid customer ID provided",
+  CHECKOUT_FAILED: "Checkout session creation failed",
+  PAYMENT_FAILED: "Payment processing failed",
+  SUBSCRIPTION_NOT_FOUND: "Subscription not found",
+  CUSTOMER_NOT_FOUND: "Customer not found"
+};
+
+// src/shared/utils/validation.ts
+var validateEmail = (email) => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+};
+var validateStripeId = (id, type) => {
+  const prefixes = {
+    customer: "cus_",
+    subscription: "sub_",
+    price: "price_",
+    product: "prod_",
+    payment_intent: "pi_"
+  };
+  return id.startsWith(prefixes[type]);
+};
+
+// src/native/components/CheckoutButton.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var CheckoutButton = ({
+  priceId,
+  customerId,
+  customerEmail,
+  children,
+  style,
+  textStyle,
+  disabled = false,
+  metadata,
+  trialPeriodDays,
+  onSuccess,
+  onError,
+  onLoading
+}) => {
+  const { initPaymentSheet, presentPaymentSheet } = useStripe();
+  const { isConfigured } = usePaymentsConfig();
+  const [loading, setLoading] = useState(false);
+  const handleError = (errorMessage) => {
+    onError?.(errorMessage);
+    Alert.alert("Payment Error", errorMessage);
+    console.error("Checkout error:", errorMessage);
+  };
+  const handleCheckout = async () => {
+    if (!isConfigured) {
+      handleError(ERROR_MESSAGES.PROVIDER_NOT_CONFIGURED);
+      return;
+    }
+    if (!validateStripeId(priceId, "price")) {
+      handleError(ERROR_MESSAGES.INVALID_PRICE_ID);
+      return;
+    }
+    if (customerId && !validateStripeId(customerId, "customer")) {
+      handleError(ERROR_MESSAGES.INVALID_CUSTOMER_ID);
+      return;
+    }
+    setLoading(true);
+    onLoading?.(true);
+    try {
+      const response = await fetch("/api/payments/create-subscription-setup", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          priceId,
+          customerId,
+          customerEmail,
+          metadata,
+          trialPeriodDays
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({ error: "Network error" }));
+        throw new Error(errorData.error || ERROR_MESSAGES.CHECKOUT_FAILED);
+      }
+      const {
+        setupIntentClientSecret,
+        customerId: returnedCustomerId,
+        customerEphemeralKeySecret
+      } = await response.json();
+      if (!setupIntentClientSecret) {
+        throw new Error("No setup intent client secret returned from server");
+      }
+      const { error: initError } = await initPaymentSheet({
+        setupIntentClientSecret,
+        customerId: returnedCustomerId,
+        customerEphemeralKeySecret,
+        merchantDisplayName: "Your App Name",
+        // TODO: Make this configurable
+        allowsDelayedPaymentMethods: true
+      });
+      if (initError) {
+        throw new Error(
+          initError.message || "Failed to initialize payment sheet"
+        );
+      }
+      const { error: presentError } = await presentPaymentSheet();
+      if (presentError) {
+        if (presentError.code !== "Canceled") {
+          throw new Error(
+            presentError.message || ERROR_MESSAGES.PAYMENT_FAILED
+          );
+        }
+        return;
+      }
+      onSuccess?.();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : ERROR_MESSAGES.CHECKOUT_FAILED;
+      handleError(errorMessage);
+    } finally {
+      setLoading(false);
+      onLoading?.(false);
+    }
+  };
+  const isDisabled = loading || disabled || !isConfigured;
+  return /* @__PURE__ */ jsxs(
+    TouchableOpacity,
+    {
+      style: [styles.button, style, isDisabled && styles.disabled],
+      onPress: handleCheckout,
+      disabled: isDisabled,
+      activeOpacity: 0.8,
+      children: [
+        loading ? /* @__PURE__ */ jsx2(ActivityIndicator, { color: "#ffffff", size: "small", style: styles.loader }) : null,
+        /* @__PURE__ */ jsx2(
+          Text,
+          {
+            style: [styles.buttonText, textStyle, loading && styles.loadingText],
+            children: loading ? "Processing..." : children
+          }
+        )
+      ]
+    }
+  );
+};
+var styles = StyleSheet.create({
+  button: {
+    backgroundColor: "#007AFF",
+    paddingHorizontal: 16,
+    paddingVertical: 12,
+    borderRadius: 8,
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "center",
+    minHeight: 48
+  },
+  buttonText: {
+    color: "#ffffff",
+    fontSize: 16,
+    fontWeight: "600",
+    textAlign: "center"
+  },
+  disabled: {
+    opacity: 0.5
+  },
+  loader: {
+    marginRight: 8
+  },
+  loadingText: {
+    marginLeft: 8
+  }
+});
+
+// src/native/components/PricingTable.tsx
+import {
+  View,
+  Text as Text2,
+  ScrollView,
+  StyleSheet as StyleSheet2,
+  Dimensions
+} from "react-native";
+
+// src/shared/utils/formatting.ts
+var formatCurrency = (amount, currency = DEFAULT_CURRENCY, options = {}) => {
+  const { showSymbol = true, showCents = true, locale = "en-US" } = options;
+  const currencyCode = currency.toUpperCase();
+  const isZeroDecimalCurrency = ["JPY", "KRW", "VND", "CLP"].includes(
+    currencyCode
+  );
+  const displayAmount = isZeroDecimalCurrency ? amount : amount / 100;
+  if (showSymbol) {
+    try {
+      return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: currencyCode,
+        minimumFractionDigits: showCents && !isZeroDecimalCurrency ? 2 : 0,
+        maximumFractionDigits: showCents && !isZeroDecimalCurrency ? 2 : 0
+      }).format(displayAmount);
+    } catch (error) {
+      const symbol = CURRENCY_SYMBOLS[currencyCode] || currencyCode;
+      const formattedAmount = showCents && !isZeroDecimalCurrency ? displayAmount.toFixed(2) : Math.round(displayAmount).toString();
+      return `${symbol}${formattedAmount}`;
+    }
+  }
+  return showCents && !isZeroDecimalCurrency ? displayAmount.toFixed(2) : Math.round(displayAmount).toString();
+};
+var formatPricingPlan = (plan) => {
+  const price = formatCurrency(plan.price, plan.currency);
+  const interval = plan.intervalCount && plan.intervalCount > 1 ? `${plan.intervalCount} ${plan.interval}s` : plan.interval;
+  return `${price}/${interval}`;
+};
+var formatTrialPeriod = (days) => {
+  if (days === 0) return "No trial";
+  if (days === 1) return "1 day trial";
+  if (days < 7) return `${days} days trial`;
+  if (days === 7) return "1 week trial";
+  if (days < 30) return `${Math.floor(days / 7)} weeks trial`;
+  if (days === 30) return "1 month trial";
+  return `${Math.floor(days / 30)} months trial`;
+};
+
+// src/native/components/PricingTable.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var { width: screenWidth } = Dimensions.get("window");
+var PricingTable = ({
+  plans,
+  customerId,
+  customerEmail,
+  onPlanSelect,
+  onCheckoutSuccess,
+  onCheckoutError,
+  showFeatures = true,
+  showTrialInfo = true,
+  layout = "carousel",
+  containerStyle
+}) => {
+  if (!plans || plans.length === 0) {
+    return /* @__PURE__ */ jsx3(View, { style: styles2.emptyContainer, children: /* @__PURE__ */ jsx3(Text2, { style: styles2.emptyText, children: "No pricing plans available" }) });
+  }
+  const renderPricingCard = (plan, index) => /* @__PURE__ */ jsx3(
+    PricingCard,
+    {
+      plan,
+      customerId,
+      customerEmail,
+      onSelect: () => onPlanSelect?.(plan),
+      onCheckoutSuccess: () => onCheckoutSuccess?.(plan),
+      onCheckoutError: (error) => onCheckoutError?.(plan, error),
+      showFeatures,
+      showTrialInfo,
+      style: layout === "carousel" ? styles2.carouselCard : styles2.listCard
+    },
+    plan.id
+  );
+  if (layout === "carousel") {
+    return /* @__PURE__ */ jsx3(View, { style: [styles2.container, containerStyle], children: /* @__PURE__ */ jsx3(
+      ScrollView,
+      {
+        horizontal: true,
+        showsHorizontalScrollIndicator: false,
+        contentContainerStyle: styles2.carouselContainer,
+        snapToInterval: screenWidth * 0.8 + 16,
+        decelerationRate: "fast",
+        children: plans.map(renderPricingCard)
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx3(ScrollView, { style: [styles2.container, containerStyle], children: /* @__PURE__ */ jsx3(View, { style: styles2.listContainer, children: plans.map(renderPricingCard) }) });
+};
+var PricingCard = ({
+  plan,
+  customerId,
+  customerEmail,
+  onSelect,
+  onCheckoutSuccess,
+  onCheckoutError,
+  showFeatures = true,
+  showTrialInfo = true,
+  style
+}) => {
+  const isPopular = plan.popular;
+  return /* @__PURE__ */ jsxs2(View, { style: [styles2.card, isPopular && styles2.popularCard, style], children: [
+    isPopular && /* @__PURE__ */ jsx3(View, { style: styles2.popularBadge, children: /* @__PURE__ */ jsx3(Text2, { style: styles2.popularBadgeText, children: "Most Popular" }) }),
+    /* @__PURE__ */ jsxs2(View, { style: styles2.cardHeader, children: [
+      /* @__PURE__ */ jsx3(Text2, { style: styles2.planName, children: plan.name }),
+      plan.description && /* @__PURE__ */ jsx3(Text2, { style: styles2.planDescription, children: plan.description }),
+      /* @__PURE__ */ jsx3(Text2, { style: styles2.planPrice, children: formatPricingPlan(plan) }),
+      showTrialInfo && plan.trialPeriodDays && plan.trialPeriodDays > 0 && /* @__PURE__ */ jsx3(Text2, { style: styles2.trialInfo, children: formatTrialPeriod(plan.trialPeriodDays) })
+    ] }),
+    showFeatures && plan.features && plan.features.length > 0 && /* @__PURE__ */ jsx3(View, { style: styles2.featuresContainer, children: plan.features.map((feature, index) => /* @__PURE__ */ jsxs2(View, { style: styles2.featureItem, children: [
+      /* @__PURE__ */ jsx3(Text2, { style: styles2.featureCheckmark, children: "\u2713" }),
+      /* @__PURE__ */ jsx3(Text2, { style: styles2.featureText, children: feature })
+    ] }, index)) }),
+    /* @__PURE__ */ jsx3(View, { style: styles2.buttonContainer, children: /* @__PURE__ */ jsx3(
+      CheckoutButton,
+      {
+        priceId: plan.stripePriceId,
+        customerId,
+        customerEmail,
+        trialPeriodDays: plan.trialPeriodDays,
+        metadata: plan.metadata,
+        onSuccess: onCheckoutSuccess,
+        onError: onCheckoutError,
+        style: [
+          styles2.ctaButton,
+          isPopular ? styles2.popularButton : styles2.regularButton
+        ],
+        textStyle: [
+          styles2.ctaButtonText,
+          isPopular ? styles2.popularButtonText : styles2.regularButtonText
+        ],
+        children: "Get Started"
+      }
+    ) })
+  ] });
+};
+var styles2 = StyleSheet2.create({
+  container: {
+    flex: 1
+  },
+  emptyContainer: {
+    flex: 1,
+    justifyContent: "center",
+    alignItems: "center",
+    padding: 20
+  },
+  emptyText: {
+    fontSize: 16,
+    color: "#666",
+    textAlign: "center"
+  },
+  carouselContainer: {
+    paddingHorizontal: 16
+  },
+  listContainer: {
+    padding: 16
+  },
+  carouselCard: {
+    width: screenWidth * 0.8,
+    marginRight: 16
+  },
+  listCard: {
+    marginBottom: 16
+  },
+  card: {
+    backgroundColor: "#ffffff",
+    borderRadius: 12,
+    padding: 20,
+    shadowColor: "#000",
+    shadowOffset: {
+      width: 0,
+      height: 2
+    },
+    shadowOpacity: 0.1,
+    shadowRadius: 8,
+    elevation: 4,
+    borderWidth: 1,
+    borderColor: "#e0e0e0"
+  },
+  popularCard: {
+    borderColor: "#007AFF",
+    borderWidth: 2
+  },
+  popularBadge: {
+    position: "absolute",
+    top: -1,
+    left: -1,
+    right: -1,
+    backgroundColor: "#007AFF",
+    paddingVertical: 8,
+    borderTopLeftRadius: 12,
+    borderTopRightRadius: 12,
+    alignItems: "center"
+  },
+  popularBadgeText: {
+    color: "#ffffff",
+    fontSize: 12,
+    fontWeight: "600"
+  },
+  cardHeader: {
+    alignItems: "center",
+    marginBottom: 20,
+    marginTop: 20
+    // Extra space for popular badge
+  },
+  planName: {
+    fontSize: 20,
+    fontWeight: "700",
+    color: "#333",
+    marginBottom: 8,
+    textAlign: "center"
+  },
+  planDescription: {
+    fontSize: 14,
+    color: "#666",
+    textAlign: "center",
+    marginBottom: 16,
+    lineHeight: 20
+  },
+  planPrice: {
+    fontSize: 28,
+    fontWeight: "800",
+    color: "#333",
+    marginBottom: 8,
+    textAlign: "center"
+  },
+  trialInfo: {
+    fontSize: 12,
+    color: "#22c55e",
+    fontWeight: "600",
+    textAlign: "center"
+  },
+  featuresContainer: {
+    marginBottom: 24
+  },
+  featureItem: {
+    flexDirection: "row",
+    alignItems: "flex-start",
+    marginBottom: 12
+  },
+  featureCheckmark: {
+    color: "#22c55e",
+    fontSize: 16,
+    fontWeight: "700",
+    marginRight: 12,
+    marginTop: 2
+  },
+  featureText: {
+    flex: 1,
+    fontSize: 14,
+    color: "#555",
+    lineHeight: 20
+  },
+  buttonContainer: {
+    marginTop: "auto"
+  },
+  ctaButton: {
+    paddingVertical: 16,
+    borderRadius: 8
+  },
+  ctaButtonText: {
+    fontSize: 16,
+    fontWeight: "600"
+  },
+  popularButton: {
+    backgroundColor: "#007AFF"
+  },
+  popularButtonText: {
+    color: "#ffffff"
+  },
+  regularButton: {
+    backgroundColor: "#f8f9fa",
+    borderWidth: 1,
+    borderColor: "#e0e0e0"
+  },
+  regularButtonText: {
+    color: "#333"
+  }
+});
+
+// src/native/components/PaymentForm.tsx
+import { useState as useState2 } from "react";
+import {
+  View as View2,
+  Text as Text3,
+  TextInput,
+  TouchableOpacity as TouchableOpacity2,
+  StyleSheet as StyleSheet3,
+  Alert as Alert2,
+  ActivityIndicator as ActivityIndicator2,
+  KeyboardAvoidingView,
+  Platform,
+  ScrollView as ScrollView2
+} from "react-native";
+import { useStripe as useStripe2, CardField } from "@stripe/stripe-react-native";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var PaymentForm = ({
+  clientSecret,
+  customerId,
+  customerEmail,
+  amount,
+  currency = "usd",
+  description,
+  metadata,
+  onSuccess,
+  onError,
+  onLoading,
+  containerStyle,
+  showBillingDetails = true
+}) => {
+  const { confirmPayment } = useStripe2();
+  const { isConfigured } = usePaymentsConfig();
+  const [loading, setLoading] = useState2(false);
+  const [email, setEmail] = useState2(customerEmail || "");
+  const [name, setName] = useState2("");
+  const [phone, setPhone] = useState2("");
+  const [cardComplete, setCardComplete] = useState2(false);
+  const handleError = (errorMessage) => {
+    onError?.(errorMessage);
+    Alert2.alert("Payment Error", errorMessage);
+    console.error("Payment error:", errorMessage);
+  };
+  const handlePayment = async () => {
+    if (!isConfigured) {
+      handleError(ERROR_MESSAGES.PROVIDER_NOT_CONFIGURED);
+      return;
+    }
+    if (showBillingDetails && email && !validateEmail(email)) {
+      handleError("Please enter a valid email address");
+      return;
+    }
+    if (!cardComplete) {
+      handleError("Please complete your card information");
+      return;
+    }
+    let paymentClientSecret = clientSecret;
+    if (!paymentClientSecret && amount) {
+      try {
+        const response = await fetch("/api/payments/create-payment-intent", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            amount,
+            currency,
+            customerId,
+            description,
+            metadata
+          })
+        });
+        if (!response.ok) {
+          throw new Error("Failed to create payment intent");
+        }
+        const { client_secret } = await response.json();
+        paymentClientSecret = client_secret;
+      } catch (error) {
+        handleError("Failed to initialize payment");
+        return;
+      }
+    }
+    if (!paymentClientSecret) {
+      handleError("Payment could not be initialized");
+      return;
+    }
+    setLoading(true);
+    onLoading?.(true);
+    try {
+      const billingDetails = showBillingDetails ? {
+        email: email || void 0,
+        name: name || void 0,
+        phone: phone || void 0
+      } : void 0;
+      const { error, paymentIntent } = await confirmPayment(
+        paymentClientSecret,
+        {
+          paymentMethodType: "Card",
+          paymentMethodData: {
+            billingDetails
+          }
+        }
+      );
+      if (error) {
+        throw new Error(error.message || ERROR_MESSAGES.PAYMENT_FAILED);
+      }
+      if (paymentIntent?.status === "Succeeded") {
+        onSuccess?.(paymentIntent);
+        Alert2.alert("Success", "Payment completed successfully!");
+      } else {
+        throw new Error("Payment was not completed");
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : ERROR_MESSAGES.PAYMENT_FAILED;
+      handleError(errorMessage);
+    } finally {
+      setLoading(false);
+      onLoading?.(false);
+    }
+  };
+  return /* @__PURE__ */ jsx4(
+    KeyboardAvoidingView,
+    {
+      behavior: Platform.OS === "ios" ? "padding" : "height",
+      style: [styles3.container, containerStyle],
+      children: /* @__PURE__ */ jsxs3(ScrollView2, { showsVerticalScrollIndicator: false, children: [
+        showBillingDetails && /* @__PURE__ */ jsxs3(View2, { style: styles3.billingSection, children: [
+          /* @__PURE__ */ jsx4(Text3, { style: styles3.sectionTitle, children: "Billing Information" }),
+          /* @__PURE__ */ jsxs3(View2, { style: styles3.inputContainer, children: [
+            /* @__PURE__ */ jsx4(Text3, { style: styles3.inputLabel, children: "Email *" }),
+            /* @__PURE__ */ jsx4(
+              TextInput,
+              {
+                style: styles3.textInput,
+                value: email,
+                onChangeText: setEmail,
+                placeholder: "your@email.com",
+                keyboardType: "email-address",
+                autoCapitalize: "none",
+                autoCorrect: false
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs3(View2, { style: styles3.inputContainer, children: [
+            /* @__PURE__ */ jsx4(Text3, { style: styles3.inputLabel, children: "Full Name" }),
+            /* @__PURE__ */ jsx4(
+              TextInput,
+              {
+                style: styles3.textInput,
+                value: name,
+                onChangeText: setName,
+                placeholder: "John Doe",
+                autoCapitalize: "words"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs3(View2, { style: styles3.inputContainer, children: [
+            /* @__PURE__ */ jsx4(Text3, { style: styles3.inputLabel, children: "Phone" }),
+            /* @__PURE__ */ jsx4(
+              TextInput,
+              {
+                style: styles3.textInput,
+                value: phone,
+                onChangeText: setPhone,
+                placeholder: "+1 (555) 123-4567",
+                keyboardType: "phone-pad"
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs3(View2, { style: styles3.cardSection, children: [
+          /* @__PURE__ */ jsx4(Text3, { style: styles3.sectionTitle, children: "Payment Information" }),
+          /* @__PURE__ */ jsx4(View2, { style: styles3.cardContainer, children: /* @__PURE__ */ jsx4(
+            CardField,
+            {
+              postalCodeEnabled: true,
+              placeholders: {
+                number: "4242 4242 4242 4242"
+              },
+              cardStyle: styles3.cardField,
+              style: styles3.cardFieldContainer,
+              onCardChange: (cardDetails) => {
+                setCardComplete(cardDetails.complete);
+              }
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ jsx4(
+          TouchableOpacity2,
+          {
+            style: [styles3.payButton, loading && styles3.payButtonDisabled],
+            onPress: handlePayment,
+            disabled: loading || !cardComplete,
+            activeOpacity: 0.8,
+            children: loading ? /* @__PURE__ */ jsx4(ActivityIndicator2, { color: "#ffffff", size: "small" }) : /* @__PURE__ */ jsxs3(Text3, { style: styles3.payButtonText, children: [
+              "Pay ",
+              amount ? `$${(amount / 100).toFixed(2)}` : ""
+            ] })
+          }
+        )
+      ] })
+    }
+  );
+};
+var styles3 = StyleSheet3.create({
+  container: {
+    flex: 1,
+    padding: 20,
+    backgroundColor: "#ffffff"
+  },
+  billingSection: {
+    marginBottom: 24
+  },
+  cardSection: {
+    marginBottom: 32
+  },
+  sectionTitle: {
+    fontSize: 18,
+    fontWeight: "600",
+    color: "#333",
+    marginBottom: 16
+  },
+  inputContainer: {
+    marginBottom: 16
+  },
+  inputLabel: {
+    fontSize: 14,
+    fontWeight: "500",
+    color: "#555",
+    marginBottom: 8
+  },
+  textInput: {
+    borderWidth: 1,
+    borderColor: "#ddd",
+    borderRadius: 8,
+    paddingHorizontal: 12,
+    paddingVertical: 12,
+    fontSize: 16,
+    backgroundColor: "#fafafa"
+  },
+  cardContainer: {
+    borderWidth: 1,
+    borderColor: "#ddd",
+    borderRadius: 8,
+    backgroundColor: "#fafafa"
+  },
+  cardFieldContainer: {
+    width: "100%",
+    height: 50
+  },
+  cardField: {
+    backgroundColor: "#fafafa",
+    textColor: "#333",
+    fontSize: 16,
+    placeholderColor: "#999"
+  },
+  payButton: {
+    backgroundColor: "#007AFF",
+    paddingVertical: 16,
+    borderRadius: 8,
+    alignItems: "center",
+    justifyContent: "center",
+    minHeight: 52
+  },
+  payButtonDisabled: {
+    opacity: 0.5
+  },
+  payButtonText: {
+    color: "#ffffff",
+    fontSize: 18,
+    fontWeight: "600"
+  }
+});
+
+// src/native/providers/StripeProvider.tsx
+import { StripeProvider as RNStripeProvider } from "@stripe/stripe-react-native";
+import { View as View3, Text as Text4, StyleSheet as StyleSheet4 } from "react-native";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var StripeProvider = ({
+  children,
+  merchantIdentifier,
+  urlScheme,
+  setReturnUrlSchemeOnAndroid = false
+}) => {
+  const { config, isConfigured } = usePaymentsConfig();
+  if (!isConfigured) {
+    if (config.environment === "development") {
+      return /* @__PURE__ */ jsxs4(View3, { style: styles4.errorContainer, children: [
+        /* @__PURE__ */ jsx5(Text4, { style: styles4.errorTitle, children: "Payments Provider Error" }),
+        /* @__PURE__ */ jsx5(Text4, { style: styles4.errorMessage, children: ERROR_MESSAGES.PROVIDER_NOT_CONFIGURED }),
+        /* @__PURE__ */ jsx5(Text4, { style: styles4.errorSubtext, children: "Please check your PaymentsProvider configuration." })
+      ] });
+    }
+    return null;
+  }
+  return /* @__PURE__ */ jsx5(
+    RNStripeProvider,
+    {
+      publishableKey: config.publishableKey,
+      merchantIdentifier,
+      urlScheme,
+      setReturnUrlSchemeOnAndroid,
+      children
+    }
+  );
+};
+var styles4 = StyleSheet4.create({
+  errorContainer: {
+    padding: 20,
+    backgroundColor: "#fee",
+    borderColor: "#fcc",
+    borderWidth: 1,
+    borderRadius: 4,
+    margin: 10
+  },
+  errorTitle: {
+    fontWeight: "bold",
+    fontSize: 16,
+    color: "#c53030",
+    marginBottom: 8
+  },
+  errorMessage: {
+    fontSize: 14,
+    color: "#c53030",
+    marginBottom: 4
+  },
+  errorSubtext: {
+    fontSize: 12,
+    color: "#a0a0a0"
+  }
+});
+
+// src/native/hooks/useSubscription.ts
+import { useState as useState3, useEffect, useCallback } from "react";
+import { Alert as Alert3 } from "react-native";
+var useSubscription = (options = {}) => {
+  const {
+    customerId,
+    subscriptionId,
+    autoFetch = true,
+    onError,
+    showErrorAlert = true
+  } = options;
+  const [subscription, setSubscription] = useState3(null);
+  const [subscriptions, setSubscriptions] = useState3([]);
+  const [loading, setLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const handleError = useCallback(
+    (errorMessage) => {
+      setError(errorMessage);
+      onError?.(errorMessage);
+      if (showErrorAlert) {
+        Alert3.alert("Subscription Error", errorMessage);
+      }
+      console.error("Subscription error:", errorMessage);
+    },
+    [onError, showErrorAlert]
+  );
+  const fetchSubscription2 = useCallback(
+    async (id) => {
+      if (!validateStripeId(id, "subscription")) {
+        handleError("Invalid subscription ID");
+        return null;
+      }
+      try {
+        const response = await fetch(`/api/payments/subscription/${id}`);
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(
+            errorData.error || ERROR_MESSAGES.SUBSCRIPTION_NOT_FOUND
+          );
+        }
+        const data = await response.json();
+        return data;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : ERROR_MESSAGES.SUBSCRIPTION_NOT_FOUND;
+        handleError(errorMessage);
+        return null;
+      }
+    },
+    [handleError]
+  );
+  const fetchCustomerSubscriptions2 = useCallback(
+    async (id) => {
+      if (!validateStripeId(id, "customer")) {
+        handleError("Invalid customer ID");
+        return [];
+      }
+      try {
+        const response = await fetch(
+          `/api/payments/customer/${id}/subscriptions`
+        );
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || ERROR_MESSAGES.CUSTOMER_NOT_FOUND);
+        }
+        const data = await response.json();
+        return data.subscriptions || [];
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : ERROR_MESSAGES.CUSTOMER_NOT_FOUND;
+        handleError(errorMessage);
+        return [];
+      }
+    },
+    [handleError]
+  );
+  const refetch = useCallback(async () => {
+    if (!customerId && !subscriptionId) {
+      handleError("Either customerId or subscriptionId is required");
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      if (subscriptionId) {
+        const sub = await fetchSubscription2(subscriptionId);
+        setSubscription(sub);
+      }
+      if (customerId) {
+        const subs = await fetchCustomerSubscriptions2(customerId);
+        setSubscriptions(subs);
+        if (!subscriptionId && subs.length > 0) {
+          const activeSub = subs.find((s) => s.status === "active") || subs[0];
+          setSubscription(activeSub);
+        }
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [
+    customerId,
+    subscriptionId,
+    fetchSubscription2,
+    fetchCustomerSubscriptions2,
+    handleError
+  ]);
+  const cancel = useCallback(
+    async (targetSubscriptionId) => {
+      const idToCancel = targetSubscriptionId || subscriptionId;
+      if (!idToCancel) {
+        handleError("Subscription ID is required to cancel");
+        return false;
+      }
+      if (!validateStripeId(idToCancel, "subscription")) {
+        handleError("Invalid subscription ID");
+        return false;
+      }
+      return new Promise((resolve) => {
+        Alert3.alert(
+          "Cancel Subscription",
+          "Are you sure you want to cancel your subscription? It will remain active until the end of your current billing period.",
+          [
+            {
+              text: "Keep Subscription",
+              style: "cancel",
+              onPress: () => resolve(false)
+            },
+            {
+              text: "Cancel Subscription",
+              style: "destructive",
+              onPress: async () => {
+                try {
+                  const response = await fetch(
+                    `/api/payments/subscription/${idToCancel}/cancel`,
+                    {
+                      method: "POST",
+                      headers: { "Content-Type": "application/json" }
+                    }
+                  );
+                  if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({ error: "Network error" }));
+                    throw new Error(
+                      errorData.error || "Failed to cancel subscription"
+                    );
+                  }
+                  await refetch();
+                  Alert3.alert(
+                    "Success",
+                    "Your subscription has been cancelled and will end at the end of your current billing period."
+                  );
+                  resolve(true);
+                } catch (err) {
+                  const errorMessage = err instanceof Error ? err.message : "Failed to cancel subscription";
+                  handleError(errorMessage);
+                  resolve(false);
+                }
+              }
+            }
+          ]
+        );
+      });
+    },
+    [subscriptionId, refetch, handleError]
+  );
+  const reactivate = useCallback(
+    async (targetSubscriptionId) => {
+      const idToReactivate = targetSubscriptionId || subscriptionId;
+      if (!idToReactivate) {
+        handleError("Subscription ID is required to reactivate");
+        return false;
+      }
+      if (!validateStripeId(idToReactivate, "subscription")) {
+        handleError("Invalid subscription ID");
+        return false;
+      }
+      try {
+        const response = await fetch(
+          `/api/payments/subscription/${idToReactivate}/reactivate`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(
+            errorData.error || "Failed to reactivate subscription"
+          );
+        }
+        await refetch();
+        Alert3.alert("Success", "Your subscription has been reactivated!");
+        return true;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to reactivate subscription";
+        handleError(errorMessage);
+        return false;
+      }
+    },
+    [subscriptionId, refetch, handleError]
+  );
+  const updatePaymentMethod = useCallback(
+    async (targetSubscriptionId, paymentMethodId) => {
+      if (!validateStripeId(targetSubscriptionId, "subscription")) {
+        handleError("Invalid subscription ID");
+        return false;
+      }
+      try {
+        const response = await fetch(
+          `/api/payments/subscription/${targetSubscriptionId}/payment-method`,
+          {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ paymentMethodId })
+          }
+        );
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || "Failed to update payment method");
+        }
+        await refetch();
+        Alert3.alert("Success", "Payment method updated successfully!");
+        return true;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update payment method";
+        handleError(errorMessage);
+        return false;
+      }
+    },
+    [refetch, handleError]
+  );
+  useEffect(() => {
+    if (autoFetch && (customerId || subscriptionId)) {
+      refetch();
+    }
+  }, [autoFetch, customerId, subscriptionId, refetch]);
+  return {
+    subscription,
+    subscriptions,
+    loading,
+    error,
+    refetch,
+    cancel,
+    reactivate,
+    updatePaymentMethod
+  };
+};
+
+// src/native/hooks/useCheckout.ts
+import { useState as useState4, useCallback as useCallback2 } from "react";
+import { Alert as Alert4 } from "react-native";
+import { useStripe as useStripe3 } from "@stripe/stripe-react-native";
+var useCheckout = (options = {}) => {
+  const {
+    onSuccess,
+    onError,
+    onLoading,
+    showErrorAlert = true,
+    showSuccessAlert = true
+  } = options;
+  const { initPaymentSheet, presentPaymentSheet, confirmPayment } = useStripe3();
+  const { isConfigured } = usePaymentsConfig();
+  const [loading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const handleError = useCallback2(
+    (errorMessage) => {
+      setError(errorMessage);
+      onError?.(errorMessage);
+      if (showErrorAlert) {
+        Alert4.alert("Payment Error", errorMessage);
+      }
+      console.error("Checkout error:", errorMessage);
+    },
+    [onError, showErrorAlert]
+  );
+  const handleSuccess = useCallback2(
+    (result) => {
+      onSuccess?.(result);
+      if (showSuccessAlert) {
+        Alert4.alert("Success", "Payment completed successfully!");
+      }
+    },
+    [onSuccess, showSuccessAlert]
+  );
+  const createSubscription = useCallback2(
+    async (params) => {
+      if (!isConfigured) {
+        handleError(ERROR_MESSAGES.PROVIDER_NOT_CONFIGURED);
+        return false;
+      }
+      if (!validateStripeId(params.priceId, "price")) {
+        handleError(ERROR_MESSAGES.INVALID_PRICE_ID);
+        return false;
+      }
+      if (params.customerId && !validateStripeId(params.customerId, "customer")) {
+        handleError(ERROR_MESSAGES.INVALID_CUSTOMER_ID);
+        return false;
+      }
+      if (params.customerEmail && !validateEmail(params.customerEmail)) {
+        handleError("Invalid customer email");
+        return false;
+      }
+      setLoading(true);
+      setError(null);
+      onLoading?.(true);
+      try {
+        const response = await fetch(
+          "/api/payments/create-subscription-setup",
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(params)
+          }
+        );
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(
+            errorData.error || "Failed to create subscription setup"
+          );
+        }
+        const {
+          setupIntentClientSecret,
+          customerId: returnedCustomerId,
+          customerEphemeralKeySecret
+        } = await response.json();
+        if (!setupIntentClientSecret) {
+          throw new Error("No setup intent client secret returned from server");
+        }
+        const { error: initError } = await initPaymentSheet({
+          setupIntentClientSecret,
+          customerId: returnedCustomerId,
+          customerEphemeralKeySecret,
+          merchantDisplayName: "Your App Name",
+          // TODO: Make this configurable
+          allowsDelayedPaymentMethods: true
+        });
+        if (initError) {
+          throw new Error(
+            initError.message || "Failed to initialize payment sheet"
+          );
+        }
+        const { error: presentError } = await presentPaymentSheet();
+        if (presentError) {
+          if (presentError.code === "Canceled") {
+            return false;
+          }
+          throw new Error(
+            presentError.message || ERROR_MESSAGES.PAYMENT_FAILED
+          );
+        }
+        handleSuccess({ type: "subscription", customerId: returnedCustomerId });
+        return true;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create subscription";
+        handleError(errorMessage);
+        return false;
+      } finally {
+        setLoading(false);
+        onLoading?.(false);
+      }
+    },
+    [
+      isConfigured,
+      initPaymentSheet,
+      presentPaymentSheet,
+      handleError,
+      handleSuccess,
+      onLoading
+    ]
+  );
+  const createPaymentIntent2 = useCallback2(
+    async (params) => {
+      if (!isConfigured) {
+        handleError(ERROR_MESSAGES.PROVIDER_NOT_CONFIGURED);
+        return null;
+      }
+      if (params.amount <= 0) {
+        handleError("Amount must be greater than 0");
+        return null;
+      }
+      if (params.customerId && !validateStripeId(params.customerId, "customer")) {
+        handleError(ERROR_MESSAGES.INVALID_CUSTOMER_ID);
+        return null;
+      }
+      setLoading(true);
+      setError(null);
+      onLoading?.(true);
+      try {
+        const response = await fetch("/api/payments/create-payment-intent", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(params)
+        });
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || "Failed to create payment intent");
+        }
+        const { client_secret } = await response.json();
+        if (!client_secret) {
+          throw new Error("No client secret returned from server");
+        }
+        return client_secret;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create payment intent";
+        handleError(errorMessage);
+        return null;
+      } finally {
+        setLoading(false);
+        onLoading?.(false);
+      }
+    },
+    [isConfigured, handleError, onLoading]
+  );
+  const processPayment = useCallback2(
+    async (clientSecret, billingDetails) => {
+      if (!isConfigured) {
+        handleError(ERROR_MESSAGES.PROVIDER_NOT_CONFIGURED);
+        return false;
+      }
+      if (billingDetails?.email && !validateEmail(billingDetails.email)) {
+        handleError("Invalid email address");
+        return false;
+      }
+      setLoading(true);
+      setError(null);
+      onLoading?.(true);
+      try {
+        const { error: error2, paymentIntent } = await confirmPayment(clientSecret, {
+          paymentMethodType: "Card",
+          paymentMethodData: {
+            billingDetails
+          }
+        });
+        if (error2) {
+          throw new Error(error2.message || ERROR_MESSAGES.PAYMENT_FAILED);
+        }
+        if (paymentIntent?.status === "Succeeded") {
+          handleSuccess({ type: "payment", paymentIntent });
+          return true;
+        } else {
+          throw new Error("Payment was not completed");
+        }
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : ERROR_MESSAGES.PAYMENT_FAILED;
+        handleError(errorMessage);
+        return false;
+      } finally {
+        setLoading(false);
+        onLoading?.(false);
+      }
+    },
+    [isConfigured, confirmPayment, handleError, handleSuccess, onLoading]
+  );
+  return {
+    loading,
+    error,
+    createSubscription,
+    createPaymentIntent: createPaymentIntent2,
+    processPayment
+  };
+};
+
+// src/native/hooks/useCustomer.ts
+import { useState as useState5, useEffect as useEffect2, useCallback as useCallback3 } from "react";
+import { Alert as Alert5 } from "react-native";
+var useCustomer = (options = {}) => {
+  const {
+    customerId,
+    autoFetch = true,
+    onError,
+    showErrorAlert = true,
+    showSuccessAlert = true
+  } = options;
+  const [customer, setCustomer] = useState5(null);
+  const [paymentMethods, setPaymentMethods] = useState5([]);
+  const [loading, setLoading] = useState5(false);
+  const [error, setError] = useState5(null);
+  const handleError = useCallback3(
+    (errorMessage) => {
+      setError(errorMessage);
+      onError?.(errorMessage);
+      if (showErrorAlert) {
+        Alert5.alert("Customer Error", errorMessage);
+      }
+      console.error("Customer error:", errorMessage);
+    },
+    [onError, showErrorAlert]
+  );
+  const handleSuccess = useCallback3(
+    (message) => {
+      if (showSuccessAlert) {
+        Alert5.alert("Success", message);
+      }
+    },
+    [showSuccessAlert]
+  );
+  const fetchCustomer = useCallback3(
+    async (id) => {
+      if (!validateStripeId(id, "customer")) {
+        handleError("Invalid customer ID");
+        return null;
+      }
+      try {
+        const response = await fetch(`/api/payments/customer/${id}`);
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || ERROR_MESSAGES.CUSTOMER_NOT_FOUND);
+        }
+        const data = await response.json();
+        return data;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : ERROR_MESSAGES.CUSTOMER_NOT_FOUND;
+        handleError(errorMessage);
+        return null;
+      }
+    },
+    [handleError]
+  );
+  const refetch = useCallback3(async () => {
+    if (!customerId) {
+      handleError("Customer ID is required");
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const customerData = await fetchCustomer(customerId);
+      setCustomer(customerData);
+    } finally {
+      setLoading(false);
+    }
+  }, [customerId, fetchCustomer, handleError]);
+  const createCustomer2 = useCallback3(
+    async (params) => {
+      if (!validateEmail(params.email)) {
+        handleError("Invalid email address");
+        return null;
+      }
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await fetch("/api/payments/customer", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(params)
+        });
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || "Failed to create customer");
+        }
+        const customerData = await response.json();
+        setCustomer(customerData);
+        handleSuccess("Customer created successfully!");
+        return customerData;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create customer";
+        handleError(errorMessage);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [handleError, handleSuccess]
+  );
+  const updateCustomer = useCallback3(
+    async (params) => {
+      if (!customerId) {
+        handleError("Customer ID is required");
+        return false;
+      }
+      if (params.email && !validateEmail(params.email)) {
+        handleError("Invalid email address");
+        return false;
+      }
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await fetch(`/api/payments/customer/${customerId}`, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(params)
+        });
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || "Failed to update customer");
+        }
+        await refetch();
+        handleSuccess("Customer updated successfully!");
+        return true;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update customer";
+        handleError(errorMessage);
+        return false;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [customerId, refetch, handleError, handleSuccess]
+  );
+  const deleteCustomer = useCallback3(async () => {
+    if (!customerId) {
+      handleError("Customer ID is required");
+      return false;
+    }
+    return new Promise((resolve) => {
+      Alert5.alert(
+        "Delete Customer",
+        "Are you sure you want to delete this customer? This action cannot be undone.",
+        [
+          {
+            text: "Cancel",
+            style: "cancel",
+            onPress: () => resolve(false)
+          },
+          {
+            text: "Delete",
+            style: "destructive",
+            onPress: async () => {
+              setLoading(true);
+              setError(null);
+              try {
+                const response = await fetch(
+                  `/api/payments/customer/${customerId}`,
+                  {
+                    method: "DELETE"
+                  }
+                );
+                if (!response.ok) {
+                  const errorData = await response.json().catch(() => ({ error: "Network error" }));
+                  throw new Error(
+                    errorData.error || "Failed to delete customer"
+                  );
+                }
+                setCustomer(null);
+                setPaymentMethods([]);
+                handleSuccess("Customer deleted successfully!");
+                resolve(true);
+              } catch (err) {
+                const errorMessage = err instanceof Error ? err.message : "Failed to delete customer";
+                handleError(errorMessage);
+                resolve(false);
+              } finally {
+                setLoading(false);
+              }
+            }
+          }
+        ]
+      );
+    });
+  }, [customerId, handleError, handleSuccess]);
+  const fetchPaymentMethods = useCallback3(async () => {
+    if (!customerId) {
+      handleError("Customer ID is required");
+      return [];
+    }
+    try {
+      const response = await fetch(
+        `/api/payments/customer/${customerId}/payment-methods`
+      );
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({ error: "Network error" }));
+        throw new Error(errorData.error || "Failed to fetch payment methods");
+      }
+      const data = await response.json();
+      const methods = data.paymentMethods || [];
+      setPaymentMethods(methods);
+      return methods;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to fetch payment methods";
+      handleError(errorMessage);
+      return [];
+    }
+  }, [customerId, handleError]);
+  const addPaymentMethod = useCallback3(
+    async (paymentMethodId) => {
+      if (!customerId) {
+        handleError("Customer ID is required");
+        return false;
+      }
+      try {
+        const response = await fetch(
+          `/api/payments/customer/${customerId}/payment-methods`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ paymentMethodId })
+          }
+        );
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(errorData.error || "Failed to add payment method");
+        }
+        await fetchPaymentMethods();
+        handleSuccess("Payment method added successfully!");
+        return true;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to add payment method";
+        handleError(errorMessage);
+        return false;
+      }
+    },
+    [customerId, fetchPaymentMethods, handleError, handleSuccess]
+  );
+  const removePaymentMethod = useCallback3(
+    async (paymentMethodId) => {
+      if (!customerId) {
+        handleError("Customer ID is required");
+        return false;
+      }
+      return new Promise((resolve) => {
+        Alert5.alert(
+          "Remove Payment Method",
+          "Are you sure you want to remove this payment method?",
+          [
+            {
+              text: "Cancel",
+              style: "cancel",
+              onPress: () => resolve(false)
+            },
+            {
+              text: "Remove",
+              style: "destructive",
+              onPress: async () => {
+                try {
+                  const response = await fetch(
+                    `/api/payments/customer/${customerId}/payment-methods/${paymentMethodId}`,
+                    {
+                      method: "DELETE"
+                    }
+                  );
+                  if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({ error: "Network error" }));
+                    throw new Error(
+                      errorData.error || "Failed to remove payment method"
+                    );
+                  }
+                  await fetchPaymentMethods();
+                  handleSuccess("Payment method removed successfully!");
+                  resolve(true);
+                } catch (err) {
+                  const errorMessage = err instanceof Error ? err.message : "Failed to remove payment method";
+                  handleError(errorMessage);
+                  resolve(false);
+                }
+              }
+            }
+          ]
+        );
+      });
+    },
+    [customerId, fetchPaymentMethods, handleError, handleSuccess]
+  );
+  const setDefaultPaymentMethod = useCallback3(
+    async (paymentMethodId) => {
+      if (!customerId) {
+        handleError("Customer ID is required");
+        return false;
+      }
+      try {
+        const response = await fetch(
+          `/api/payments/customer/${customerId}/default-payment-method`,
+          {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ paymentMethodId })
+          }
+        );
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: "Network error" }));
+          throw new Error(
+            errorData.error || "Failed to set default payment method"
+          );
+        }
+        await Promise.all([refetch(), fetchPaymentMethods()]);
+        handleSuccess("Default payment method updated successfully!");
+        return true;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to set default payment method";
+        handleError(errorMessage);
+        return false;
+      }
+    },
+    [customerId, refetch, fetchPaymentMethods, handleError, handleSuccess]
+  );
+  useEffect2(() => {
+    if (autoFetch && customerId) {
+      refetch();
+      fetchPaymentMethods();
+    }
+  }, [autoFetch, customerId, refetch, fetchPaymentMethods]);
+  return {
+    customer,
+    paymentMethods,
+    loading,
+    error,
+    refetch,
+    createCustomer: createCustomer2,
+    updateCustomer,
+    deleteCustomer,
+    fetchPaymentMethods,
+    addPaymentMethod,
+    removePaymentMethod,
+    setDefaultPaymentMethod
+  };
+};
+
+// src/native/utils/stripe-native.ts
+var createSubscriptionSetup = async (params) => {
+  try {
+    const response = await fetch("/api/payments/create-subscription-setup", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Network error" }));
+      return {
+        error: errorData.error || "Failed to create subscription setup"
+      };
+    }
+    const data = await response.json();
+    return {
+      setupIntentClientSecret: data.setupIntentClientSecret,
+      customerId: data.customerId,
+      customerEphemeralKeySecret: data.customerEphemeralKeySecret
+    };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : "Failed to create subscription setup"
+    };
+  }
+};
+var createPaymentIntent = async (params) => {
+  try {
+    const response = await fetch("/api/payments/create-payment-intent", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Network error" }));
+      return { error: errorData.error || "Failed to create payment intent" };
+    }
+    const data = await response.json();
+    return { clientSecret: data.client_secret };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : "Failed to create payment intent"
+    };
+  }
+};
+var validatePaymentsConfig = (config) => {
+  const errors = [];
+  if (!config.publishableKey) {
+    errors.push("publishableKey is required");
+  }
+  if (!config.provider) {
+    errors.push("provider is required");
+  }
+  if (config.provider !== "stripe") {
+    errors.push("Only stripe provider is currently supported");
+  }
+  if (!config.environment) {
+    errors.push("environment is required");
+  }
+  if (config.environment && !["development", "production"].includes(config.environment)) {
+    errors.push('environment must be either "development" or "production"');
+  }
+  if (config.publishableKey && !config.publishableKey.startsWith("pk_")) {
+    errors.push('publishableKey must start with "pk_"');
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+};
+var formatStripeError = (error) => {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error?.message) {
+    return error.message;
+  }
+  if (error?.code) {
+    const errorMessages = {
+      Canceled: "Payment was cancelled",
+      Failed: "Payment failed",
+      card_declined: "Your card was declined.",
+      expired_card: "Your card has expired.",
+      incorrect_cvc: "Your card's security code is incorrect.",
+      processing_error: "An error occurred while processing your card.",
+      incorrect_number: "Your card number is incorrect."
+    };
+    return errorMessages[error.code] || `Payment failed: ${error.code}`;
+  }
+  return "An unexpected error occurred.";
+};
+var createCustomer = async (params) => {
+  try {
+    const response = await fetch("/api/payments/customer", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Network error" }));
+      return { error: errorData.error || "Failed to create customer" };
+    }
+    const customer = await response.json();
+    return { customer };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : "Failed to create customer"
+    };
+  }
+};
+var fetchSubscription = async (subscriptionId) => {
+  try {
+    const response = await fetch(
+      `/api/payments/subscription/${subscriptionId}`
+    );
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Network error" }));
+      return {
+        error: errorData.error || ERROR_MESSAGES.SUBSCRIPTION_NOT_FOUND
+      };
+    }
+    const subscription = await response.json();
+    return { subscription };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : ERROR_MESSAGES.SUBSCRIPTION_NOT_FOUND
+    };
+  }
+};
+var fetchCustomerSubscriptions = async (customerId) => {
+  try {
+    const response = await fetch(
+      `/api/payments/customer/${customerId}/subscriptions`
+    );
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Network error" }));
+      return { error: errorData.error || ERROR_MESSAGES.CUSTOMER_NOT_FOUND };
+    }
+    const data = await response.json();
+    return { subscriptions: data.subscriptions || [] };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : ERROR_MESSAGES.CUSTOMER_NOT_FOUND
+    };
+  }
+};
+var cancelSubscription = async (subscriptionId) => {
+  try {
+    const response = await fetch(
+      `/api/payments/subscription/${subscriptionId}/cancel`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Network error" }));
+      return {
+        success: false,
+        error: errorData.error || "Failed to cancel subscription"
+      };
+    }
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to cancel subscription"
+    };
+  }
+};
+export {
+  CheckoutButton,
+  PaymentForm,
+  PricingTable,
+  StripeProvider,
+  cancelSubscription,
+  createCustomer,
+  createPaymentIntent,
+  createSubscriptionSetup,
+  fetchCustomerSubscriptions,
+  fetchSubscription,
+  formatStripeError,
+  useCheckout,
+  useCustomer,
+  useSubscription,
+  validatePaymentsConfig
+};