@stripe-sdk/core 1.0.0

package/dist/index.js

@@ -0,0 +1,1800 @@
+'use strict';
+
+var Stripe = require('stripe');
+var react = require('react');
+var stripeJs = require('@stripe/stripe-js');
+var reactStripeJs = require('@stripe/react-stripe-js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Stripe__default = /*#__PURE__*/_interopDefault(Stripe);
+
+// src/server/stripe-client.ts
+var stripeInstance = null;
+var currentConfig = null;
+function initStripe(config) {
+  currentConfig = config;
+  stripeInstance = new Stripe__default.default(config.secretKey, {
+    apiVersion: config.apiVersion ?? "2025-01-27.acacia",
+    appInfo: config.appInfo ?? {
+      name: "@stripe-sdk/core",
+      version: "1.0.0"
+    }
+  });
+  return stripeInstance;
+}
+function getStripe() {
+  if (!stripeInstance) {
+    throw new Error(
+      "[@stripe-sdk/core] Stripe not initialized. Call initStripe({ secretKey, publishableKey }) first."
+    );
+  }
+  return stripeInstance;
+}
+function getConfig() {
+  if (!currentConfig) {
+    throw new Error(
+      "[@stripe-sdk/core] Stripe not initialized. Call initStripe({ secretKey, publishableKey }) first."
+    );
+  }
+  return currentConfig;
+}
+
+// src/utils/errors.ts
+function handleStripeError(error) {
+  if (error?.type) {
+    const stripeError = error;
+    return {
+      data: null,
+      error: {
+        message: stripeError.message,
+        type: stripeError.type,
+        code: stripeError.code,
+        statusCode: stripeError.statusCode
+      }
+    };
+  }
+  return {
+    data: null,
+    error: {
+      message: error instanceof Error ? error.message : "An unknown error occurred",
+      type: "sdk_error"
+    }
+  };
+}
+function success(data) {
+  return { data, error: null };
+}
+
+// src/server/payments/index.ts
+async function createPaymentIntent(input) {
+  try {
+    const stripe = getStripe();
+    const paymentIntent = await stripe.paymentIntents.create({
+      amount: input.amount,
+      currency: input.currency,
+      customer: input.customerId,
+      payment_method: input.paymentMethodId,
+      metadata: input.metadata,
+      description: input.description,
+      receipt_email: input.receiptEmail,
+      setup_future_usage: input.setupFutureUsage,
+      automatic_payment_methods: input.automaticPaymentMethods === false || input.paymentMethodId ? void 0 : { enabled: true },
+      return_url: input.returnUrl
+    });
+    return success(paymentIntent);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrievePaymentIntent(paymentIntentId) {
+  try {
+    const stripe = getStripe();
+    const paymentIntent = await stripe.paymentIntents.retrieve(paymentIntentId);
+    return success(paymentIntent);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function confirmPaymentIntent(input) {
+  try {
+    const stripe = getStripe();
+    const paymentIntent = await stripe.paymentIntents.confirm(input.paymentIntentId, {
+      payment_method: input.paymentMethodId,
+      return_url: input.returnUrl
+    });
+    return success(paymentIntent);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function cancelPaymentIntent(paymentIntentId) {
+  try {
+    const stripe = getStripe();
+    const paymentIntent = await stripe.paymentIntents.cancel(paymentIntentId);
+    return success(paymentIntent);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listPaymentIntents(input) {
+  try {
+    const stripe = getStripe();
+    const paymentIntents = await stripe.paymentIntents.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      customer: input?.customerId
+    });
+    return success(paymentIntents);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function createCheckoutSession(input) {
+  try {
+    const stripe = getStripe();
+    const session = await stripe.checkout.sessions.create({
+      mode: input.mode,
+      line_items: input.lineItems.map((item) => ({
+        price: item.priceId,
+        quantity: item.quantity
+      })),
+      success_url: input.successUrl,
+      cancel_url: input.cancelUrl,
+      customer: input.customerId,
+      customer_email: input.customerEmail,
+      metadata: input.metadata,
+      allow_promotion_codes: input.allowPromotionCodes,
+      shipping_address_collection: input.shippingAddressCollection ? { allowed_countries: input.shippingAddressCollection.allowedCountries } : void 0,
+      billing_address_collection: input.billingAddressCollection,
+      subscription_data: input.trialPeriodDays ? { trial_period_days: input.trialPeriodDays } : void 0,
+      tax_id_collection: input.taxIdCollection ? { enabled: true } : void 0,
+      automatic_tax: input.automaticTax ? { enabled: true } : void 0,
+      locale: input.locale
+    });
+    return success(session);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrieveCheckoutSession(sessionId) {
+  try {
+    const stripe = getStripe();
+    const session = await stripe.checkout.sessions.retrieve(sessionId, {
+      expand: ["line_items", "payment_intent", "subscription"]
+    });
+    return success(session);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listCheckoutSessions(input) {
+  try {
+    const stripe = getStripe();
+    const sessions = await stripe.checkout.sessions.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore
+    });
+    return success(sessions);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function createPaymentLink(input) {
+  try {
+    const stripe = getStripe();
+    const paymentLink = await stripe.paymentLinks.create({
+      line_items: input.lineItems.map((item) => ({
+        price: item.priceId,
+        quantity: item.quantity,
+        adjustable_quantity: item.adjustableQuantity ? {
+          enabled: item.adjustableQuantity.enabled,
+          minimum: item.adjustableQuantity.minimum,
+          maximum: item.adjustableQuantity.maximum
+        } : void 0
+      })),
+      metadata: input.metadata,
+      after_completion: input.afterCompletion ? {
+        type: input.afterCompletion.type,
+        redirect: input.afterCompletion.redirectUrl ? { url: input.afterCompletion.redirectUrl } : void 0
+      } : void 0,
+      allow_promotion_codes: input.allowPromotionCodes,
+      automatic_tax: input.automaticTax ? { enabled: true } : void 0,
+      billing_address_collection: input.billingAddressCollection,
+      shipping_address_collection: input.shippingAddressCollection ? { allowed_countries: input.shippingAddressCollection.allowedCountries } : void 0
+    });
+    return success(paymentLink);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrievePaymentLink(paymentLinkId) {
+  try {
+    const stripe = getStripe();
+    const paymentLink = await stripe.paymentLinks.retrieve(paymentLinkId);
+    return success(paymentLink);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function createSetupIntent(input) {
+  try {
+    const stripe = getStripe();
+    const setupIntent = await stripe.setupIntents.create({
+      customer: input.customerId,
+      payment_method_types: input.paymentMethodTypes,
+      usage: input.usage,
+      metadata: input.metadata
+    });
+    return success(setupIntent);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrieveSetupIntent(setupIntentId) {
+  try {
+    const stripe = getStripe();
+    const setupIntent = await stripe.setupIntents.retrieve(setupIntentId);
+    return success(setupIntent);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listPaymentMethods(customerId, type) {
+  try {
+    const stripe = getStripe();
+    const paymentMethods = await stripe.paymentMethods.list({
+      customer: customerId,
+      type: type ?? "card"
+    });
+    return success(paymentMethods);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function attachPaymentMethod(paymentMethodId, customerId) {
+  try {
+    const stripe = getStripe();
+    const paymentMethod = await stripe.paymentMethods.attach(paymentMethodId, {
+      customer: customerId
+    });
+    return success(paymentMethod);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function detachPaymentMethod(paymentMethodId) {
+  try {
+    const stripe = getStripe();
+    const paymentMethod = await stripe.paymentMethods.detach(paymentMethodId);
+    return success(paymentMethod);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+
+// src/server/customers/index.ts
+async function createCustomer(input) {
+  try {
+    const stripe = getStripe();
+    const customer = await stripe.customers.create({
+      email: input.email,
+      name: input.name,
+      phone: input.phone,
+      description: input.description,
+      metadata: input.metadata,
+      payment_method: input.paymentMethodId,
+      invoice_settings: input.paymentMethodId ? { default_payment_method: input.paymentMethodId } : void 0,
+      address: input.address ? {
+        line1: input.address.line1,
+        line2: input.address.line2,
+        city: input.address.city,
+        state: input.address.state,
+        postal_code: input.address.postalCode,
+        country: input.address.country
+      } : void 0
+    });
+    return success(customer);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrieveCustomer(customerId) {
+  try {
+    const stripe = getStripe();
+    const customer = await stripe.customers.retrieve(customerId, {
+      expand: ["subscriptions", "sources"]
+    });
+    if (customer.deleted) {
+      return {
+        data: null,
+        error: { message: "Customer has been deleted", type: "invalid_request_error" }
+      };
+    }
+    return success(customer);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function updateCustomer(input) {
+  try {
+    const stripe = getStripe();
+    const customer = await stripe.customers.update(input.customerId, {
+      email: input.email,
+      name: input.name,
+      phone: input.phone,
+      description: input.description,
+      metadata: input.metadata,
+      invoice_settings: input.defaultPaymentMethodId ? { default_payment_method: input.defaultPaymentMethodId } : void 0,
+      address: input.address ? {
+        line1: input.address.line1,
+        line2: input.address.line2,
+        city: input.address.city,
+        state: input.address.state,
+        postal_code: input.address.postalCode,
+        country: input.address.country
+      } : void 0
+    });
+    return success(customer);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function deleteCustomer(customerId) {
+  try {
+    const stripe = getStripe();
+    const deleted = await stripe.customers.del(customerId);
+    return success(deleted);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listCustomers(input) {
+  try {
+    const stripe = getStripe();
+    const customers = await stripe.customers.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      email: input?.email
+    });
+    return success(customers);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function searchCustomers(query, limit) {
+  try {
+    const stripe = getStripe();
+    const customers = await stripe.customers.search({
+      query,
+      limit: limit ?? 10
+    });
+    return success(customers);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function createPortalSession(input) {
+  try {
+    const stripe = getStripe();
+    const session = await stripe.billingPortal.sessions.create({
+      customer: input.customerId,
+      return_url: input.returnUrl,
+      configuration: input.configuration
+    });
+    return success(session);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+
+// src/server/subscriptions/index.ts
+async function createSubscription(input) {
+  try {
+    const stripe = getStripe();
+    const items = input.items ? input.items.map((item) => ({ price: item.priceId, quantity: item.quantity })) : [{ price: input.priceId, quantity: input.quantity ?? 1 }];
+    const subscription = await stripe.subscriptions.create({
+      customer: input.customerId,
+      items,
+      metadata: input.metadata,
+      trial_period_days: input.trialPeriodDays,
+      coupon: input.couponId,
+      promotion_code: input.promotionCodeId,
+      payment_behavior: input.paymentBehavior ?? "default_incomplete",
+      cancel_at_period_end: input.cancelAtPeriodEnd,
+      billing_cycle_anchor: input.billingCycleAnchor,
+      proration_behavior: input.prorationBehavior,
+      expand: ["latest_invoice.payment_intent"]
+    });
+    return success(subscription);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrieveSubscription(subscriptionId) {
+  try {
+    const stripe = getStripe();
+    const subscription = await stripe.subscriptions.retrieve(subscriptionId, {
+      expand: ["latest_invoice.payment_intent", "default_payment_method"]
+    });
+    return success(subscription);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function updateSubscription(input) {
+  try {
+    const stripe = getStripe();
+    const params = {
+      metadata: input.metadata,
+      cancel_at_period_end: input.cancelAtPeriodEnd,
+      proration_behavior: input.prorationBehavior,
+      coupon: input.couponId
+    };
+    if (input.items) {
+      params.items = input.items.map((item) => ({
+        id: item.id,
+        price: item.priceId,
+        quantity: item.quantity
+      }));
+    }
+    const subscription = await stripe.subscriptions.update(input.subscriptionId, params);
+    return success(subscription);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function cancelSubscription(input) {
+  try {
+    const stripe = getStripe();
+    if (input.cancelAtPeriodEnd) {
+      const subscription2 = await stripe.subscriptions.update(input.subscriptionId, {
+        cancel_at_period_end: true,
+        cancellation_details: input.cancellationDetails ? {
+          comment: input.cancellationDetails.comment,
+          feedback: input.cancellationDetails.feedback
+        } : void 0
+      });
+      return success(subscription2);
+    }
+    const subscription = await stripe.subscriptions.cancel(input.subscriptionId, {
+      cancellation_details: input.cancellationDetails ? {
+        comment: input.cancellationDetails.comment,
+        feedback: input.cancellationDetails.feedback
+      } : void 0
+    });
+    return success(subscription);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function resumeSubscription(subscriptionId) {
+  try {
+    const stripe = getStripe();
+    const subscription = await stripe.subscriptions.update(subscriptionId, {
+      cancel_at_period_end: false
+    });
+    return success(subscription);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listSubscriptions(input) {
+  try {
+    const stripe = getStripe();
+    const subscriptions = await stripe.subscriptions.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      customer: input?.customerId,
+      status: input?.status
+    });
+    return success(subscriptions);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+
+// src/server/products/index.ts
+async function createProduct(input) {
+  try {
+    const stripe = getStripe();
+    const product = await stripe.products.create({
+      name: input.name,
+      description: input.description,
+      images: input.images,
+      metadata: input.metadata,
+      active: input.active,
+      default_price_data: input.defaultPriceData ? {
+        unit_amount: input.defaultPriceData.unitAmount,
+        currency: input.defaultPriceData.currency,
+        recurring: input.defaultPriceData.recurring ? {
+          interval: input.defaultPriceData.recurring.interval,
+          interval_count: input.defaultPriceData.recurring.intervalCount
+        } : void 0
+      } : void 0
+    });
+    return success(product);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrieveProduct(productId) {
+  try {
+    const stripe = getStripe();
+    const product = await stripe.products.retrieve(productId);
+    return success(product);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function updateProduct(input) {
+  try {
+    const stripe = getStripe();
+    const product = await stripe.products.update(input.productId, {
+      name: input.name,
+      description: input.description,
+      images: input.images,
+      metadata: input.metadata,
+      active: input.active
+    });
+    return success(product);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function archiveProduct(productId) {
+  try {
+    const stripe = getStripe();
+    const product = await stripe.products.update(productId, { active: false });
+    return success(product);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listProducts(input) {
+  try {
+    const stripe = getStripe();
+    const products = await stripe.products.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      active: input?.active
+    });
+    return success(products);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function createPrice(input) {
+  try {
+    const stripe = getStripe();
+    const params = {
+      product: input.productId,
+      currency: input.currency,
+      metadata: input.metadata,
+      active: input.active,
+      nickname: input.nickname,
+      lookup_key: input.lookupKey,
+      billing_scheme: input.billingScheme,
+      recurring: input.recurring ? {
+        interval: input.recurring.interval,
+        interval_count: input.recurring.intervalCount
+      } : void 0
+    };
+    if (input.billingScheme === "tiered" && input.tiers) {
+      if (!input.tiersMode) {
+        throw new Error('tiersMode is required when billingScheme is "tiered"');
+      }
+      params.tiers = input.tiers.map((tier) => ({
+        up_to: tier.upTo,
+        unit_amount: tier.unitAmount,
+        flat_amount: tier.flatAmount
+      }));
+      params.tiers_mode = input.tiersMode;
+    } else {
+      params.unit_amount = input.unitAmount;
+    }
+    const price = await stripe.prices.create(params);
+    return success(price);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrievePrice(priceId) {
+  try {
+    const stripe = getStripe();
+    const price = await stripe.prices.retrieve(priceId);
+    return success(price);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listPrices(input) {
+  try {
+    const stripe = getStripe();
+    const prices = await stripe.prices.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      product: input?.productId,
+      active: input?.active,
+      type: input?.type
+    });
+    return success(prices);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function archivePrice(priceId) {
+  try {
+    const stripe = getStripe();
+    const price = await stripe.prices.update(priceId, { active: false });
+    return success(price);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+
+// src/server/invoices/index.ts
+async function createInvoice(input) {
+  try {
+    const stripe = getStripe();
+    const invoice = await stripe.invoices.create({
+      customer: input.customerId,
+      collection_method: input.collectionMethod ?? "charge_automatically",
+      days_until_due: input.daysUntilDue,
+      metadata: input.metadata,
+      description: input.description,
+      auto_advance: input.autoAdvance
+    });
+    return success(invoice);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrieveInvoice(invoiceId) {
+  try {
+    const stripe = getStripe();
+    const invoice = await stripe.invoices.retrieve(invoiceId);
+    return success(invoice);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function finalizeInvoice(invoiceId) {
+  try {
+    const stripe = getStripe();
+    const invoice = await stripe.invoices.finalizeInvoice(invoiceId);
+    return success(invoice);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function sendInvoice(invoiceId) {
+  try {
+    const stripe = getStripe();
+    const invoice = await stripe.invoices.sendInvoice(invoiceId);
+    return success(invoice);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function payInvoice(invoiceId) {
+  try {
+    const stripe = getStripe();
+    const invoice = await stripe.invoices.pay(invoiceId);
+    return success(invoice);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function voidInvoice(invoiceId) {
+  try {
+    const stripe = getStripe();
+    const invoice = await stripe.invoices.voidInvoice(invoiceId);
+    return success(invoice);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listInvoices(input) {
+  try {
+    const stripe = getStripe();
+    const invoices = await stripe.invoices.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      customer: input?.customerId,
+      status: input?.status
+    });
+    return success(invoices);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function getUpcomingInvoice(customerId, subscriptionId) {
+  try {
+    const stripe = getStripe();
+    const invoice = await stripe.invoices.retrieveUpcoming({
+      customer: customerId,
+      subscription: subscriptionId
+    });
+    return success(invoice);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function createInvoiceItem(input) {
+  try {
+    const stripe = getStripe();
+    const invoiceItem = await stripe.invoiceItems.create({
+      customer: input.customerId,
+      invoice: input.invoiceId,
+      price: input.priceId,
+      amount: input.amount,
+      currency: input.currency,
+      description: input.description,
+      quantity: input.quantity,
+      metadata: input.metadata
+    });
+    return success(invoiceItem);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+
+// src/server/refunds/index.ts
+async function createRefund(input) {
+  try {
+    const stripe = getStripe();
+    const refund = await stripe.refunds.create({
+      payment_intent: input.paymentIntentId,
+      charge: input.chargeId,
+      amount: input.amount,
+      reason: input.reason,
+      metadata: input.metadata
+    });
+    return success(refund);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrieveRefund(refundId) {
+  try {
+    const stripe = getStripe();
+    const refund = await stripe.refunds.retrieve(refundId);
+    return success(refund);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listRefunds(input) {
+  try {
+    const stripe = getStripe();
+    const refunds = await stripe.refunds.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      payment_intent: input?.paymentIntentId,
+      charge: input?.chargeId
+    });
+    return success(refunds);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrieveDispute(disputeId) {
+  try {
+    const stripe = getStripe();
+    const dispute = await stripe.disputes.retrieve(disputeId);
+    return success(dispute);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function updateDispute(input) {
+  try {
+    const stripe = getStripe();
+    const dispute = await stripe.disputes.update(input.disputeId, {
+      evidence: input.evidence ? {
+        customer_name: input.evidence.customerName,
+        customer_email_address: input.evidence.customerEmailAddress,
+        customer_communication: input.evidence.customerCommunication,
+        product_description: input.evidence.productDescription,
+        shipping_documentation: input.evidence.shippingDocumentation,
+        service_documentation: input.evidence.serviceDocumentation,
+        uncategorized_text: input.evidence.uncategorizedText
+      } : void 0,
+      metadata: input.metadata,
+      submit: input.submit
+    });
+    return success(dispute);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function closeDispute(disputeId) {
+  try {
+    const stripe = getStripe();
+    const dispute = await stripe.disputes.close(disputeId);
+    return success(dispute);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listDisputes(input) {
+  try {
+    const stripe = getStripe();
+    const disputes = await stripe.disputes.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore
+    });
+    return success(disputes);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+
+// src/server/connect/index.ts
+async function createConnectAccount(input) {
+  try {
+    const stripe = getStripe();
+    const account = await stripe.accounts.create({
+      type: input.type,
+      country: input.country,
+      email: input.email,
+      capabilities: input.capabilities,
+      business_type: input.businessType,
+      metadata: input.metadata
+    });
+    return success(account);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrieveConnectAccount(accountId) {
+  try {
+    const stripe = getStripe();
+    const account = await stripe.accounts.retrieve(accountId);
+    return success(account);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function deleteConnectAccount(accountId) {
+  try {
+    const stripe = getStripe();
+    const deleted = await stripe.accounts.del(accountId);
+    return success(deleted);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listConnectAccounts(input) {
+  try {
+    const stripe = getStripe();
+    const accounts = await stripe.accounts.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore
+    });
+    return success(accounts);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function createAccountLink(input) {
+  try {
+    const stripe = getStripe();
+    const accountLink = await stripe.accountLinks.create({
+      account: input.accountId,
+      refresh_url: input.refreshUrl,
+      return_url: input.returnUrl,
+      type: input.type
+    });
+    return success(accountLink);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function createTransfer(input) {
+  try {
+    const stripe = getStripe();
+    const transfer = await stripe.transfers.create({
+      amount: input.amount,
+      currency: input.currency,
+      destination: input.destinationAccountId,
+      description: input.description,
+      metadata: input.metadata,
+      source_transaction: input.sourceTransaction
+    });
+    return success(transfer);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listTransfers(input) {
+  try {
+    const stripe = getStripe();
+    const transfers = await stripe.transfers.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      destination: input?.destinationAccountId
+    });
+    return success(transfers);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function createPayout(amount, currency, metadata) {
+  try {
+    const stripe = getStripe();
+    const payout = await stripe.payouts.create({
+      amount,
+      currency,
+      metadata
+    });
+    return success(payout);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listPayouts(input) {
+  try {
+    const stripe = getStripe();
+    const payouts = await stripe.payouts.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      status: input?.status
+    });
+    return success(payouts);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function getBalance() {
+  try {
+    const stripe = getStripe();
+    const balance = await stripe.balance.retrieve();
+    return success(balance);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listBalanceTransactions(input) {
+  try {
+    const stripe = getStripe();
+    const transactions = await stripe.balanceTransactions.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      type: input?.type
+    });
+    return success(transactions);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+
+// src/server/coupons/index.ts
+async function createCoupon(input) {
+  try {
+    const stripe = getStripe();
+    const coupon = await stripe.coupons.create({
+      percent_off: input.percentOff,
+      amount_off: input.amountOff,
+      currency: input.currency,
+      duration: input.duration,
+      duration_in_months: input.durationInMonths,
+      max_redemptions: input.maxRedemptions,
+      redeem_by: input.redeemBy,
+      name: input.name,
+      metadata: input.metadata
+    });
+    return success(coupon);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrieveCoupon(couponId) {
+  try {
+    const stripe = getStripe();
+    const coupon = await stripe.coupons.retrieve(couponId);
+    return success(coupon);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function deleteCoupon(couponId) {
+  try {
+    const stripe = getStripe();
+    const deleted = await stripe.coupons.del(couponId);
+    return success(deleted);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listCoupons(input) {
+  try {
+    const stripe = getStripe();
+    const coupons = await stripe.coupons.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore
+    });
+    return success(coupons);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function createPromotionCode(input) {
+  try {
+    const stripe = getStripe();
+    const promotionCode = await stripe.promotionCodes.create({
+      coupon: input.couponId,
+      code: input.code,
+      active: input.active,
+      max_redemptions: input.maxRedemptions,
+      expires_at: input.expiresAt,
+      metadata: input.metadata,
+      restrictions: input.restrictions ? {
+        first_time_transaction: input.restrictions.firstTimeTransaction,
+        minimum_amount: input.restrictions.minimumAmount,
+        minimum_amount_currency: input.restrictions.minimumAmountCurrency
+      } : void 0
+    });
+    return success(promotionCode);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function retrievePromotionCode(promotionCodeId) {
+  try {
+    const stripe = getStripe();
+    const promotionCode = await stripe.promotionCodes.retrieve(promotionCodeId);
+    return success(promotionCode);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+async function listPromotionCodes(input) {
+  try {
+    const stripe = getStripe();
+    const promotionCodes = await stripe.promotionCodes.list({
+      limit: input?.limit ?? 10,
+      starting_after: input?.startingAfter,
+      ending_before: input?.endingBefore,
+      coupon: input?.couponId,
+      active: input?.active,
+      code: input?.code
+    });
+    return success(promotionCodes);
+  } catch (error) {
+    return handleStripeError(error);
+  }
+}
+
+// src/server/webhooks/index.ts
+var MAX_BODY_SIZE = 1024 * 1024;
+function createWebhookHandler(config) {
+  const webhookSecret = config.secret ?? getConfig().webhookSecret;
+  if (!webhookSecret) {
+    throw new Error(
+      "[@stripe-sdk/core] Webhook secret is required. Pass it via config.secret or initStripe({ webhookSecret })."
+    );
+  }
+  return async function handleWebhook(body, signature) {
+    const stripe = getStripe();
+    let event;
+    try {
+      event = stripe.webhooks.constructEvent(body, signature, webhookSecret);
+    } catch (err) {
+      const verificationError = err instanceof Error ? err : new Error("Webhook signature verification failed");
+      if (config.onError) {
+        await config.onError(verificationError);
+      }
+      throw verificationError;
+    }
+    const handler = config.handlers[event.type];
+    if (handler) {
+      try {
+        await handler(event);
+      } catch (error) {
+        if (config.onError) {
+          await config.onError(error instanceof Error ? error : new Error(String(error)), event);
+        } else {
+          throw error;
+        }
+      }
+    } else if (config.onUnhandledEvent) {
+      await config.onUnhandledEvent(event);
+    }
+    return { received: true, type: event.type };
+  };
+}
+function createNextWebhookHandler(config) {
+  const handler = createWebhookHandler(config);
+  return async function POST(request) {
+    try {
+      const contentLength = request.headers.get("content-length");
+      if (contentLength && parseInt(contentLength, 10) > MAX_BODY_SIZE) {
+        return new Response(JSON.stringify({ error: "Webhook body too large" }), {
+          status: 413,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const body = await request.text();
+      const signature = request.headers.get("stripe-signature");
+      if (!signature) {
+        return new Response(JSON.stringify({ error: "Missing stripe-signature header" }), {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const result = await handler(body, signature);
+      return new Response(JSON.stringify(result), {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Webhook handler failed";
+      return new Response(JSON.stringify({ error: message }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  };
+}
+function createPagesWebhookHandler(webhookConfig) {
+  const handler = createWebhookHandler(webhookConfig);
+  return async function webhookRoute(req, res) {
+    if (req.method !== "POST") {
+      res.status(405).end();
+      return;
+    }
+    try {
+      const body = await getRawBody(req);
+      const signature = req.headers["stripe-signature"];
+      if (!signature) {
+        res.status(400).json({ error: "Missing stripe-signature header" });
+        return;
+      }
+      const result = await handler(body, signature);
+      res.status(200).json(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Webhook handler failed";
+      res.status(400).json({ error: message });
+    }
+  };
+}
+function getRawBody(req) {
+  return new Promise((resolve, reject) => {
+    if (typeof req.body === "string") {
+      if (req.body.length > MAX_BODY_SIZE) {
+        reject(new Error("Webhook body too large"));
+        return;
+      }
+      resolve(req.body);
+      return;
+    }
+    if (Buffer.isBuffer(req.body)) {
+      if (req.body.length > MAX_BODY_SIZE) {
+        reject(new Error("Webhook body too large"));
+        return;
+      }
+      resolve(req.body.toString("utf8"));
+      return;
+    }
+    if (!req.on) {
+      reject(new Error("Cannot read raw body from request"));
+      return;
+    }
+    const chunks = [];
+    let totalLength = 0;
+    req.on("data", (chunk) => {
+      const buf = Buffer.from(chunk);
+      totalLength += buf.length;
+      if (totalLength > MAX_BODY_SIZE) {
+        reject(new Error("Webhook body too large"));
+        return;
+      }
+      chunks.push(buf);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+var StripeContext = react.createContext(null);
+function useStripeConfig() {
+  const context = react.useContext(StripeContext);
+  if (!context) {
+    throw new Error("useStripeConfig must be used within a <StripeProvider>");
+  }
+  return context;
+}
+function StripeProvider({
+  publishableKey,
+  children,
+  options,
+  locale
+}) {
+  const stripePromise = react.useMemo(
+    () => stripeJs.loadStripe(publishableKey, locale ? { locale } : void 0),
+    [publishableKey, locale]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(StripeContext.Provider, { value: { publishableKey }, children: /* @__PURE__ */ jsxRuntime.jsx(reactStripeJs.Elements, { stripe: stripePromise, options, children }) });
+}
+function StripeElementsProvider({
+  publishableKey,
+  clientSecret,
+  children,
+  appearance,
+  locale,
+  loader = "auto"
+}) {
+  const stripePromise = react.useMemo(
+    () => stripeJs.loadStripe(publishableKey, locale ? { locale } : void 0),
+    [publishableKey, locale]
+  );
+  const options = react.useMemo(
+    () => ({
+      clientSecret,
+      appearance,
+      loader
+    }),
+    [clientSecret, appearance, loader]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(StripeContext.Provider, { value: { publishableKey }, children: /* @__PURE__ */ jsxRuntime.jsx(reactStripeJs.Elements, { stripe: stripePromise, options, children }) });
+}
+function usePayment(options) {
+  const stripe = reactStripeJs.useStripe();
+  const elements = reactStripeJs.useElements();
+  const [state, setState] = react.useState({
+    isProcessing: false,
+    isSuccess: false,
+    error: null,
+    paymentIntentId: null
+  });
+  const processPayment = react.useCallback(async (overrides) => {
+    if (!stripe || !elements) {
+      setState((s) => ({ ...s, error: "Stripe not loaded yet" }));
+      return { success: false, error: "Stripe not loaded yet" };
+    }
+    setState({ isProcessing: true, isSuccess: false, error: null, paymentIntentId: null });
+    const { error, paymentIntent } = await stripe.confirmPayment({
+      elements,
+      confirmParams: {
+        return_url: overrides?.returnUrl ?? options?.returnUrl ?? (typeof window !== "undefined" ? window.location.href : "")
+      },
+      redirect: "if_required"
+    });
+    if (error) {
+      const message = error.message ?? "Payment failed";
+      setState({ isProcessing: false, isSuccess: false, error: message, paymentIntentId: null });
+      options?.onError?.(message);
+      return { success: false, error: message };
+    }
+    if (paymentIntent?.status === "succeeded") {
+      setState({ isProcessing: false, isSuccess: true, error: null, paymentIntentId: paymentIntent.id });
+      options?.onSuccess?.(paymentIntent.id);
+      return { success: true, paymentIntentId: paymentIntent.id };
+    }
+    setState({ isProcessing: false, isSuccess: false, error: null, paymentIntentId: paymentIntent?.id ?? null });
+    return { success: false, status: paymentIntent?.status };
+  }, [stripe, elements, options]);
+  const reset = react.useCallback(() => {
+    setState({ isProcessing: false, isSuccess: false, error: null, paymentIntentId: null });
+  }, []);
+  return {
+    ...state,
+    processPayment,
+    reset,
+    isReady: !!stripe && !!elements
+  };
+}
+function useSetupIntent(options) {
+  const stripe = reactStripeJs.useStripe();
+  const elements = reactStripeJs.useElements();
+  const [state, setState] = react.useState({
+    isProcessing: false,
+    isSuccess: false,
+    error: null,
+    setupIntentId: null,
+    paymentMethodId: null
+  });
+  const confirmSetup = react.useCallback(async (overrides) => {
+    if (!stripe || !elements) {
+      setState((s) => ({ ...s, error: "Stripe not loaded yet" }));
+      return { success: false, error: "Stripe not loaded yet" };
+    }
+    setState({ isProcessing: true, isSuccess: false, error: null, setupIntentId: null, paymentMethodId: null });
+    const { error, setupIntent } = await stripe.confirmSetup({
+      elements,
+      confirmParams: {
+        return_url: overrides?.returnUrl ?? options?.returnUrl ?? (typeof window !== "undefined" ? window.location.href : "")
+      },
+      redirect: "if_required"
+    });
+    if (error) {
+      const message = error.message ?? "Setup failed";
+      setState({ isProcessing: false, isSuccess: false, error: message, setupIntentId: null, paymentMethodId: null });
+      options?.onError?.(message);
+      return { success: false, error: message };
+    }
+    if (setupIntent?.status === "succeeded") {
+      const pmId = typeof setupIntent.payment_method === "string" ? setupIntent.payment_method : setupIntent.payment_method?.id ?? null;
+      setState({ isProcessing: false, isSuccess: true, error: null, setupIntentId: setupIntent.id, paymentMethodId: pmId });
+      if (pmId) options?.onSuccess?.(setupIntent.id, pmId);
+      return { success: true, setupIntentId: setupIntent.id, paymentMethodId: pmId };
+    }
+    setState({ isProcessing: false, isSuccess: false, error: null, setupIntentId: setupIntent?.id ?? null, paymentMethodId: null });
+    return { success: false, status: setupIntent?.status };
+  }, [stripe, elements, options]);
+  const reset = react.useCallback(() => {
+    setState({ isProcessing: false, isSuccess: false, error: null, setupIntentId: null, paymentMethodId: null });
+  }, []);
+  return {
+    ...state,
+    confirmSetup,
+    reset,
+    isReady: !!stripe && !!elements
+  };
+}
+function useCheckout(options) {
+  const [state, setState] = react.useState({
+    isLoading: false,
+    error: null
+  });
+  const redirectToCheckout = react.useCallback(async (sessionId) => {
+    setState({ isLoading: true, error: null });
+    try {
+      const stripe = await stripeJs.loadStripe(options.publishableKey);
+      if (!stripe) {
+        throw new Error("Failed to load Stripe");
+      }
+      const { error } = await stripe.redirectToCheckout({ sessionId });
+      if (error) {
+        const message = error.message ?? "Redirect to checkout failed";
+        setState({ isLoading: false, error: message });
+        options.onError?.(message);
+        return { success: false, error: message };
+      }
+      return { success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      setState({ isLoading: false, error: message });
+      options.onError?.(message);
+      return { success: false, error: message };
+    }
+  }, [options]);
+  const redirectToPortal = react.useCallback((portalUrl) => {
+    window.location.href = portalUrl;
+  }, []);
+  return {
+    ...state,
+    redirectToCheckout,
+    redirectToPortal
+  };
+}
+function CheckoutForm({
+  onSuccess,
+  onError,
+  returnUrl,
+  submitLabel = "Pay now",
+  showEmail = false,
+  className,
+  buttonClassName,
+  errorClassName,
+  children,
+  layout = "tabs"
+}) {
+  const { processPayment, isProcessing, isSuccess, error, isReady } = usePayment({
+    onSuccess,
+    onError,
+    returnUrl
+  });
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    await processPayment();
+  };
+  if (isSuccess) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className, children: children ?? /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Payment successful!" }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: handleSubmit, className, children: [
+    showEmail && /* @__PURE__ */ jsxRuntime.jsx(reactStripeJs.LinkAuthenticationElement, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(reactStripeJs.PaymentElement, { options: { layout } }),
+    error && /* @__PURE__ */ jsxRuntime.jsx("p", { className: errorClassName, role: "alert", children: error }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "submit",
+        disabled: !isReady || isProcessing,
+        className: buttonClassName,
+        children: isProcessing ? "Processing..." : submitLabel
+      }
+    )
+  ] });
+}
+function SetupForm({
+  onSuccess,
+  onError,
+  returnUrl,
+  submitLabel = "Save payment method",
+  className,
+  buttonClassName,
+  errorClassName,
+  successContent,
+  layout = "tabs"
+}) {
+  const { confirmSetup, isProcessing, isSuccess, error, isReady } = useSetupIntent({
+    onSuccess,
+    onError,
+    returnUrl
+  });
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    await confirmSetup();
+  };
+  if (isSuccess) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className, children: successContent ?? /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Payment method saved!" }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: handleSubmit, className, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactStripeJs.PaymentElement, { options: { layout } }),
+    error && /* @__PURE__ */ jsxRuntime.jsx("p", { className: errorClassName, role: "alert", children: error }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "submit",
+        disabled: !isReady || isProcessing,
+        className: buttonClassName,
+        children: isProcessing ? "Saving..." : submitLabel
+      }
+    )
+  ] });
+}
+function defaultFormatPrice(amount, currency) {
+  return new Intl.NumberFormat(void 0, {
+    style: "currency",
+    currency,
+    minimumFractionDigits: 0
+  }).format(amount / 100);
+}
+function PricingTable({
+  plans,
+  onSelectPlan,
+  isLoading,
+  currentPlanId,
+  buttonLabel = "Get started",
+  currentPlanLabel = "Current plan",
+  className,
+  planClassName,
+  highlightedClassName,
+  buttonClassName,
+  formatPrice = defaultFormatPrice,
+  renderFeature
+}) {
+  const defaultStyles = {
+    container: {
+      display: "grid",
+      gridTemplateColumns: `repeat(${Math.min(plans.length, 4)}, 1fr)`,
+      gap: "1.5rem",
+      maxWidth: "1200px",
+      margin: "0 auto"
+    },
+    plan: {
+      border: "1px solid #e5e7eb",
+      borderRadius: "0.75rem",
+      padding: "2rem",
+      display: "flex",
+      flexDirection: "column"
+    },
+    highlighted: {
+      border: "2px solid #6366f1",
+      boxShadow: "0 4px 14px rgba(99,102,241,0.15)"
+    },
+    badge: {
+      background: "#6366f1",
+      color: "#fff",
+      padding: "0.25rem 0.75rem",
+      borderRadius: "9999px",
+      fontSize: "0.75rem",
+      fontWeight: 600,
+      alignSelf: "flex-start",
+      marginBottom: "0.5rem"
+    },
+    name: { fontSize: "1.25rem", fontWeight: 700, margin: "0 0 0.25rem" },
+    description: { color: "#6b7280", fontSize: "0.875rem", margin: "0 0 1rem" },
+    price: { fontSize: "2.5rem", fontWeight: 800, margin: "0" },
+    interval: { color: "#6b7280", fontSize: "0.875rem", fontWeight: 400 },
+    features: { listStyle: "none", padding: 0, margin: "1.5rem 0", flex: 1 },
+    feature: { padding: "0.375rem 0", fontSize: "0.875rem" },
+    button: {
+      padding: "0.75rem 1.5rem",
+      borderRadius: "0.5rem",
+      border: "none",
+      fontWeight: 600,
+      cursor: "pointer",
+      fontSize: "0.875rem",
+      background: "#6366f1",
+      color: "#fff",
+      width: "100%"
+    },
+    currentButton: {
+      background: "#e5e7eb",
+      color: "#374151",
+      cursor: "default"
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className, style: !className ? defaultStyles.container : void 0, children: plans.map((plan) => {
+    const isCurrent = plan.id === currentPlanId;
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: plan.highlighted ? highlightedClassName : planClassName,
+        style: !planClassName ? { ...defaultStyles.plan, ...plan.highlighted ? defaultStyles.highlighted : {} } : void 0,
+        children: [
+          plan.badge && /* @__PURE__ */ jsxRuntime.jsx("span", { style: !highlightedClassName ? defaultStyles.badge : void 0, children: plan.badge }),
+          /* @__PURE__ */ jsxRuntime.jsx("h3", { style: defaultStyles.name, children: plan.name }),
+          plan.description && /* @__PURE__ */ jsxRuntime.jsx("p", { style: defaultStyles.description, children: plan.description }),
+          /* @__PURE__ */ jsxRuntime.jsxs("p", { style: defaultStyles.price, children: [
+            formatPrice(plan.amount, plan.currency),
+            plan.interval && /* @__PURE__ */ jsxRuntime.jsxs("span", { style: defaultStyles.interval, children: [
+              " / ",
+              plan.interval
+            ] })
+          ] }),
+          plan.trialDays && /* @__PURE__ */ jsxRuntime.jsxs("p", { style: { ...defaultStyles.description, marginTop: "0.5rem" }, children: [
+            plan.trialDays,
+            "-day free trial"
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("ul", { style: defaultStyles.features, children: plan.features.map((feature, i) => /* @__PURE__ */ jsxRuntime.jsx("li", { style: defaultStyles.feature, children: renderFeature ? renderFeature(feature) : `\u2713 ${feature}` }, i)) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              onClick: () => !isCurrent && onSelectPlan(plan),
+              disabled: isLoading || isCurrent,
+              className: buttonClassName,
+              style: !buttonClassName ? { ...defaultStyles.button, ...isCurrent ? defaultStyles.currentButton : {} } : void 0,
+              children: isCurrent ? currentPlanLabel : buttonLabel
+            }
+          )
+        ]
+      },
+      plan.id
+    );
+  }) });
+}
+function defaultFormatPrice2(amount, currency) {
+  return new Intl.NumberFormat(void 0, {
+    style: "currency",
+    currency,
+    minimumFractionDigits: 0
+  }).format(amount / 100);
+}
+var statusColors = {
+  active: "#10b981",
+  trialing: "#6366f1",
+  past_due: "#f59e0b",
+  canceled: "#ef4444",
+  incomplete: "#f59e0b",
+  unpaid: "#ef4444",
+  paused: "#6b7280"
+};
+function SubscriptionManager({
+  subscription,
+  onCancel,
+  onResume,
+  onChangePlan,
+  onManageBilling,
+  className,
+  formatPrice = defaultFormatPrice2,
+  cancelLabel = "Cancel subscription",
+  resumeLabel = "Resume subscription",
+  changePlanLabel = "Change plan",
+  manageBillingLabel = "Manage billing"
+}) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [showConfirm, setShowConfirm] = react.useState(false);
+  const endDate = new Date(subscription.currentPeriodEnd).toLocaleDateString();
+  const trialEndDate = subscription.trialEnd ? new Date(subscription.trialEnd).toLocaleDateString() : null;
+  const handleCancel = async () => {
+    setIsLoading(true);
+    try {
+      await onCancel(subscription.id);
+    } finally {
+      setIsLoading(false);
+      setShowConfirm(false);
+    }
+  };
+  const handleResume = async () => {
+    if (!onResume) return;
+    setIsLoading(true);
+    try {
+      await onResume(subscription.id);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const styles = {
+    container: { border: "1px solid #e5e7eb", borderRadius: "0.75rem", padding: "1.5rem" },
+    header: { display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: "1rem" },
+    planName: { fontSize: "1.25rem", fontWeight: 700, margin: 0 },
+    status: {
+      padding: "0.25rem 0.75rem",
+      borderRadius: "9999px",
+      fontSize: "0.75rem",
+      fontWeight: 600,
+      color: "#fff",
+      background: statusColors[subscription.status] ?? "#6b7280"
+    },
+    price: { fontSize: "1.5rem", fontWeight: 700, margin: "0 0 0.5rem" },
+    detail: { color: "#6b7280", fontSize: "0.875rem", margin: "0.25rem 0" },
+    actions: { display: "flex", gap: "0.75rem", marginTop: "1.5rem", flexWrap: "wrap" },
+    button: {
+      padding: "0.5rem 1rem",
+      borderRadius: "0.375rem",
+      border: "1px solid #d1d5db",
+      background: "#fff",
+      cursor: "pointer",
+      fontSize: "0.875rem",
+      fontWeight: 500
+    },
+    dangerButton: {
+      padding: "0.5rem 1rem",
+      borderRadius: "0.375rem",
+      border: "1px solid #fca5a5",
+      background: "#fef2f2",
+      color: "#dc2626",
+      cursor: "pointer",
+      fontSize: "0.875rem",
+      fontWeight: 500
+    },
+    confirm: {
+      background: "#fef2f2",
+      border: "1px solid #fca5a5",
+      borderRadius: "0.5rem",
+      padding: "1rem",
+      marginTop: "1rem"
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className, style: !className ? styles.container : void 0, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { style: styles.header, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h3", { style: styles.planName, children: subscription.planName }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { style: styles.status, children: subscription.status })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("p", { style: styles.price, children: [
+      formatPrice(subscription.amount, subscription.currency),
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { style: { fontSize: "0.875rem", fontWeight: 400, color: "#6b7280" }, children: [
+        " ",
+        "/ ",
+        subscription.interval
+      ] })
+    ] }),
+    trialEndDate && subscription.status === "trialing" && /* @__PURE__ */ jsxRuntime.jsxs("p", { style: styles.detail, children: [
+      "Trial ends on ",
+      trialEndDate
+    ] }),
+    subscription.cancelAtPeriodEnd ? /* @__PURE__ */ jsxRuntime.jsxs("p", { style: { ...styles.detail, color: "#dc2626" }, children: [
+      "Cancels on ",
+      endDate
+    ] }) : /* @__PURE__ */ jsxRuntime.jsxs("p", { style: styles.detail, children: [
+      "Renews on ",
+      endDate
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { style: styles.actions, children: [
+      onChangePlan && subscription.status === "active" && /* @__PURE__ */ jsxRuntime.jsx("button", { onClick: () => onChangePlan(subscription.id), style: styles.button, children: changePlanLabel }),
+      onManageBilling && /* @__PURE__ */ jsxRuntime.jsx("button", { onClick: onManageBilling, style: styles.button, children: manageBillingLabel }),
+      subscription.cancelAtPeriodEnd && onResume ? /* @__PURE__ */ jsxRuntime.jsx("button", { onClick: handleResume, disabled: isLoading, style: styles.button, children: isLoading ? "Loading..." : resumeLabel }) : subscription.status === "active" && /* @__PURE__ */ jsxRuntime.jsx("button", { onClick: () => setShowConfirm(true), style: styles.dangerButton, children: cancelLabel })
+    ] }),
+    showConfirm && /* @__PURE__ */ jsxRuntime.jsxs("div", { style: styles.confirm, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: "0 0 0.75rem", fontWeight: 500 }, children: "Are you sure you want to cancel?" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("p", { style: { ...styles.detail, marginBottom: "0.75rem" }, children: [
+        "You will still have access until ",
+        endDate,
+        "."
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", gap: "0.5rem" }, children: [
+        /* @__PURE__ */ jsxRuntime.jsx("button", { onClick: handleCancel, disabled: isLoading, style: styles.dangerButton, children: isLoading ? "Cancelling..." : "Confirm cancellation" }),
+        /* @__PURE__ */ jsxRuntime.jsx("button", { onClick: () => setShowConfirm(false), style: styles.button, children: "Keep subscription" })
+      ] })
+    ] })
+  ] });
+}
+
+exports.CheckoutForm = CheckoutForm;
+exports.PricingTable = PricingTable;
+exports.SetupForm = SetupForm;
+exports.StripeElementsProvider = StripeElementsProvider;
+exports.StripeProvider = StripeProvider;
+exports.SubscriptionManager = SubscriptionManager;
+exports.archivePrice = archivePrice;
+exports.archiveProduct = archiveProduct;
+exports.attachPaymentMethod = attachPaymentMethod;
+exports.cancelPaymentIntent = cancelPaymentIntent;
+exports.cancelSubscription = cancelSubscription;
+exports.closeDispute = closeDispute;
+exports.confirmPaymentIntent = confirmPaymentIntent;
+exports.createAccountLink = createAccountLink;
+exports.createCheckoutSession = createCheckoutSession;
+exports.createConnectAccount = createConnectAccount;
+exports.createCoupon = createCoupon;
+exports.createCustomer = createCustomer;
+exports.createInvoice = createInvoice;
+exports.createInvoiceItem = createInvoiceItem;
+exports.createNextWebhookHandler = createNextWebhookHandler;
+exports.createPagesWebhookHandler = createPagesWebhookHandler;
+exports.createPaymentIntent = createPaymentIntent;
+exports.createPaymentLink = createPaymentLink;
+exports.createPayout = createPayout;
+exports.createPortalSession = createPortalSession;
+exports.createPrice = createPrice;
+exports.createProduct = createProduct;
+exports.createPromotionCode = createPromotionCode;
+exports.createRefund = createRefund;
+exports.createSetupIntent = createSetupIntent;
+exports.createSubscription = createSubscription;
+exports.createTransfer = createTransfer;
+exports.createWebhookHandler = createWebhookHandler;
+exports.deleteConnectAccount = deleteConnectAccount;
+exports.deleteCoupon = deleteCoupon;
+exports.deleteCustomer = deleteCustomer;
+exports.detachPaymentMethod = detachPaymentMethod;
+exports.finalizeInvoice = finalizeInvoice;
+exports.getBalance = getBalance;
+exports.getConfig = getConfig;
+exports.getStripe = getStripe;
+exports.getUpcomingInvoice = getUpcomingInvoice;
+exports.initStripe = initStripe;
+exports.listBalanceTransactions = listBalanceTransactions;
+exports.listCheckoutSessions = listCheckoutSessions;
+exports.listConnectAccounts = listConnectAccounts;
+exports.listCoupons = listCoupons;
+exports.listCustomers = listCustomers;
+exports.listDisputes = listDisputes;
+exports.listInvoices = listInvoices;
+exports.listPaymentIntents = listPaymentIntents;
+exports.listPaymentMethods = listPaymentMethods;
+exports.listPayouts = listPayouts;
+exports.listPrices = listPrices;
+exports.listProducts = listProducts;
+exports.listPromotionCodes = listPromotionCodes;
+exports.listRefunds = listRefunds;
+exports.listSubscriptions = listSubscriptions;
+exports.listTransfers = listTransfers;
+exports.payInvoice = payInvoice;
+exports.resumeSubscription = resumeSubscription;
+exports.retrieveCheckoutSession = retrieveCheckoutSession;
+exports.retrieveConnectAccount = retrieveConnectAccount;
+exports.retrieveCoupon = retrieveCoupon;
+exports.retrieveCustomer = retrieveCustomer;
+exports.retrieveDispute = retrieveDispute;
+exports.retrieveInvoice = retrieveInvoice;
+exports.retrievePaymentIntent = retrievePaymentIntent;
+exports.retrievePaymentLink = retrievePaymentLink;
+exports.retrievePrice = retrievePrice;
+exports.retrieveProduct = retrieveProduct;
+exports.retrievePromotionCode = retrievePromotionCode;
+exports.retrieveRefund = retrieveRefund;
+exports.retrieveSetupIntent = retrieveSetupIntent;
+exports.retrieveSubscription = retrieveSubscription;
+exports.searchCustomers = searchCustomers;
+exports.sendInvoice = sendInvoice;
+exports.updateCustomer = updateCustomer;
+exports.updateDispute = updateDispute;
+exports.updateProduct = updateProduct;
+exports.updateSubscription = updateSubscription;
+exports.useCheckout = useCheckout;
+exports.usePayment = usePayment;
+exports.useSetupIntent = useSetupIntent;
+exports.useStripeConfig = useStripeConfig;
+exports.voidInvoice = voidInvoice;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map