@stripe-sdk/core 1.0.0

package/dist/server/index.js

@@ -0,0 +1,1290 @@
+'use strict';
+
+var Stripe = require('stripe');
+
+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);
+  });
+}
+
+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.voidInvoice = voidInvoice;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map