@stacksjs/payments 0.70.23 → 0.70.26

package/dist/{charge.d.ts → src/billable/charge.d.ts}

@@ -1,9 +1,9 @@
-import type { UserModel } from '../../../../orm/src/models/User';
-
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageCharge: ManageCharge;
 export declare interface ManageCharge {
   createPayment: (user: UserModel, amount: number, options: Stripe.PaymentIntentCreateParams) => Promise<Stripe.Response<Stripe.PaymentIntent>>
   findPayment: (id: string) => Promise<Stripe.PaymentIntent | null>
   refund: (paymentIntentId: string, options?: Stripe.RefundCreateParams) => Promise<Stripe.Response<Stripe.Refund>>
   charge: (user: UserModel, amount: number, paymentMethod: string, options: Stripe.PaymentIntentCreateParams) => Promise<Stripe.Response<Stripe.PaymentIntent>>
 }
-export declare const manageCharge: ManageCharge;

package/dist/{checkout.d.ts → src/billable/checkout.d.ts}

@@ -1,6 +1,6 @@
-import type { UserModel } from '../../../../orm/src/models/User';
-
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageCheckout: Checkout;
 export declare interface Checkout {
   create: (user: UserModel, params: Stripe.Checkout.SessionCreateParams) => Promise<Stripe.Response<Stripe.Checkout.Session>>
 }
-export declare const manageCheckout: Checkout;

package/dist/{customer.d.ts → src/billable/customer.d.ts}

@@ -1,6 +1,7 @@
 import type { StripeCustomerOptions } from '@stacksjs/types';
-import type { UserModel } from '../../../../orm/src/models/User';
-
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageCustomer: ManageCustomer;
 export declare interface ManageCustomer {
   stripeId: (user: UserModel) => string
   hasStripeId: (user: UserModel) => boolean
@@ -12,4 +13,3 @@ export declare interface ManageCustomer {
   deleteStripeUser: (user: UserModel) => Promise<Stripe.Response<Stripe.DeletedCustomer>>
   syncStripeCustomerDetails: (user: UserModel, options: StripeCustomerOptions) => Promise<Stripe.Response<Stripe.Customer>>
 }
-export declare const manageCustomer: ManageCustomer;

package/dist/src/billable/index.d.ts

@@ -0,0 +1,13 @@
+// Core Billable Modules
+export * from './charge';
+export * from './checkout';
+export * from './customer';
+export * from './intent';
+export * from './invoice';
+export * from './payment-method';
+export * from './price';
+export * from './product';
+export * from './setup-products';
+export * from './subscription';
+export * from './transaction';
+export * from './webhook';

package/dist/{intent.d.ts → src/billable/intent.d.ts}

@@ -1,6 +1,6 @@
-import type { UserModel } from '../../../../orm/src/models/User';
-
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageSetupIntent: SetupIntent;
 export declare interface SetupIntent {
   create: (user: UserModel, params: Stripe.SetupIntentCreateParams) => Promise<Stripe.Response<Stripe.SetupIntent>>
 }
-export declare const manageSetupIntent: SetupIntent;

package/dist/src/billable/invoice.d.ts

@@ -0,0 +1,6 @@
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageInvoice: ManageInvoice;
+export declare interface ManageInvoice {
+  list: (user: UserModel) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Invoice>>>
+}

package/dist/{payment-method.d.ts → src/billable/payment-method.d.ts}

@@ -1,15 +1,18 @@
-import type { PaymentMethodModel, PaymentMethodsTable } from '../../../../orm/src/models/PaymentMethod';
-import type { UserModel } from '../../../../orm/src/models/User';
-
+import { PaymentMethod } from '@stacksjs/orm';
+import type { ModelRow, UserModel } from '@stacksjs/orm';
+import type { Selectable } from '@stacksjs/database';
+import type Stripe from 'stripe';
+export declare const managePaymentMethod: ManagePaymentMethod;
 export declare interface ManagePaymentMethod {
   addPaymentMethod: (user: UserModel, paymentMethod: string | Stripe.PaymentMethod) => Promise<Stripe.Response<Stripe.PaymentMethod>>
   updatePaymentMethod: (user: UserModel, paymentMethodId: string, updateParams?: Stripe.PaymentMethodUpdateParams) => Promise<Stripe.Response<Stripe.PaymentMethod>>
   setUserDefaultPayment: (user: UserModel, paymentMethodId: string) => Promise<Stripe.Response<Stripe.Customer>>
   setDefaultPaymentMethod: (user: UserModel, paymentMethodId: number) => Promise<Stripe.Response<Stripe.Customer>>
-  storePaymentMethod: (user: UserModel, paymentMethodId: Stripe.PaymentMethod) => Promise<PaymentMethodModel>
-  deletePaymentMethod: (user: UserModel, paymentMethodId: number) => Promise<Stripe.Response<Stripe.PaymentMethod>>
-  retrievePaymentMethod: (user: UserModel, paymentMethodId: number) => Promise<PaymentMethodsTable | undefined>
-  retrieveDefaultPaymentMethod: (user: UserModel) => Promise<PaymentMethodModel | undefined>
-  listPaymentMethods: (user: UserModel, cardType?: string) => Promise<PaymentMethodsTable[]>
+  storePaymentMethod: (user: UserModel, paymentMethodId: Stripe.PaymentMethod) => Promise<PaymentMethodInstance>
+  deletePaymentMethod: (user: UserModel, paymentMethodId: string | number) => Promise<Stripe.Response<Stripe.PaymentMethod>>
+  retrievePaymentMethod: (user: UserModel, paymentMethodId: number) => Promise<PaymentMethodInstance | undefined>
+  retrieveDefaultPaymentMethod: (user: UserModel) => Promise<PaymentMethodInstance | undefined>
+  listPaymentMethods: (user: UserModel, cardType?: string) => Promise<Selectable<PaymentMethodsTable>[]>
 }
-export declare let managePaymentMethod: ManagePaymentMethod;
+declare type PaymentMethodInstance = NonNullable<Awaited<ReturnType<typeof PaymentMethod.find>>>;
+declare type PaymentMethodsTable = ModelRow<typeof PaymentMethod>;

package/dist/{price.d.ts → src/billable/price.d.ts}

@@ -1,5 +1,6 @@
+import type Stripe from 'stripe';
+export declare const managePrice: PriceManager;
 export declare interface PriceManager {
   retrieveByLookupKey: (lookupKey: string) => Promise<Stripe.Price | undefined>
   createOrGet: (lookupKey: string, params: Stripe.PriceCreateParams) => Promise<Stripe.Price>
 }
-export declare const managePrice: PriceManager;

package/dist/src/billable/product.d.ts

@@ -0,0 +1,37 @@
+import type Stripe from 'stripe';
+export declare const manageProduct: ProductManager;
+export declare const managePriceExtended: ExtendedPriceManager;
+export declare const manageCoupon: CouponManager;
+export declare interface ProductManager {
+  create: (params: Stripe.ProductCreateParams) => Promise<Stripe.Response<Stripe.Product>>
+  retrieve: (productId: string) => Promise<Stripe.Response<Stripe.Product>>
+  update: (productId: string, params: Stripe.ProductUpdateParams) => Promise<Stripe.Response<Stripe.Product>>
+  list: (params?: Stripe.ProductListParams) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Product>>>
+  archive: (productId: string) => Promise<Stripe.Response<Stripe.Product>>
+  createWithPrice: (product: Stripe.ProductCreateParams, price: Omit<Stripe.PriceCreateParams, 'product'>) => Promise<{ product: Stripe.Product, price: Stripe.Price }>
+  search: (query: string, params?: Stripe.ProductSearchParams) => Promise<Stripe.Response<Stripe.ApiSearchResult<Stripe.Product>>>
+}
+// =============================================================================
+// Extended Price Management
+// =============================================================================
+export declare interface ExtendedPriceManager {
+  create: (params: Stripe.PriceCreateParams) => Promise<Stripe.Response<Stripe.Price>>
+  retrieve: (priceId: string) => Promise<Stripe.Response<Stripe.Price>>
+  update: (priceId: string, params: Stripe.PriceUpdateParams) => Promise<Stripe.Response<Stripe.Price>>
+  list: (params?: Stripe.PriceListParams) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Price>>>
+  listByProduct: (productId: string, params?: Stripe.PriceListParams) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Price>>>
+  search: (query: string, params?: Stripe.PriceSearchParams) => Promise<Stripe.Response<Stripe.ApiSearchResult<Stripe.Price>>>
+  archive: (priceId: string) => Promise<Stripe.Response<Stripe.Price>>
+}
+// =============================================================================
+// Coupon and Promotion Code Management
+// =============================================================================
+export declare interface CouponManager {
+  create: (params: Stripe.CouponCreateParams) => Promise<Stripe.Response<Stripe.Coupon>>
+  retrieve: (couponId: string) => Promise<Stripe.Response<Stripe.Coupon>>
+  update: (couponId: string, params: Stripe.CouponUpdateParams) => Promise<Stripe.Response<Stripe.Coupon>>
+  delete: (couponId: string) => Promise<Stripe.Response<Stripe.DeletedCoupon>>
+  list: (params?: Stripe.CouponListParams) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Coupon>>>
+  createPromotionCode: (params: Stripe.PromotionCodeCreateParams) => Promise<Stripe.Response<Stripe.PromotionCode>>
+  retrievePromotionCode: (code: string) => Promise<Stripe.PromotionCode | null>
+}

package/dist/src/billable/setup-products.d.ts

@@ -0,0 +1,2 @@
+import type { Result } from '@stacksjs/error-handling';
+export declare function createStripeProduct(): Promise<Result<string, Error>>;

package/dist/{subscription.d.ts → src/billable/subscription.d.ts}

@@ -1,5 +1,6 @@
-import type { UserModel } from '../../../../orm/src/models/User';
-
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+export declare const manageSubscription: SubscriptionManager;
 export declare interface SubscriptionManager {
   create: (user: UserModel, type: string, lookupKey: string, params: Partial<Stripe.SubscriptionCreateParams>) => Promise<Stripe.Response<Stripe.Subscription>>
   update: (user: UserModel, type: string, lookupKey: string, params: Partial<Stripe.SubscriptionUpdateParams>) => Promise<Stripe.Response<Stripe.Subscription>>
@@ -8,4 +9,4 @@ export declare interface SubscriptionManager {
   isValid: (user: UserModel, type: string) => Promise<boolean>
   isIncomplete: (user: UserModel, type: string) => Promise<boolean>
 }
-export declare const manageSubscription: SubscriptionManager;
+declare type SubscriptionsTable = Record<string, unknown>;

package/dist/src/billable/transaction.d.ts

@@ -0,0 +1,14 @@
+import { PaymentTransaction } from '@stacksjs/orm';
+import type { ModelRow, UserModel } from '@stacksjs/orm';
+export declare const manageTransaction: ManageTransaction;
+export declare interface StoreTransactionOptions {
+  brand: string
+  provider_id: string
+  description?: string
+  type?: string
+}
+export declare interface ManageTransaction {
+  store: (user: UserModel, productId: number, options: StoreTransactionOptions) => Promise<PaymentTransactionsTable | undefined>
+  list: (user: UserModel) => Promise<PaymentTransactionsTable[]>
+}
+declare type PaymentTransactionsTable = ModelRow<typeof PaymentTransaction>;

package/dist/src/billable/webhook.d.ts

@@ -0,0 +1,130 @@
+import type Stripe from 'stripe';
+/**
+ * Register a webhook event handler
+ */
+export declare function onWebhookEvent(eventType: WebhookEventType, handler: WebhookHandler): void;
+/**
+ * Register multiple webhook handlers at once
+ */
+export declare function registerWebhookHandlers(handlerMap: Record<WebhookEventType, WebhookHandler>): void;
+/**
+ * Construct and verify a webhook event from the raw request.
+ *
+ * `tolerance` (in seconds) controls how much clock skew between Stripe and
+ * this server is acceptable before signatures are rejected. Stripe's SDK
+ * default is 300s; tightening this is recommended in production but the
+ * previous code dropped the value entirely, so a configured tolerance was
+ * silently ignored.
+ */
+export declare function constructEvent(payload: string | Buffer, signature: string, secret: string, tolerance?: number): Stripe.Event;
+/**
+ * Handle an incoming webhook event
+ */
+export declare function handleWebhookEvent(event: Stripe.Event): Promise<{ handled: boolean, eventType: string, errors?: string[] }>;
+/**
+ * Process a webhook request
+ */
+export declare function processWebhook(payload: string | Buffer, signature: string, config: WebhookConfig): Promise<{ success: boolean, eventType?: string, error?: string }>;
+/**
+ * Register payment intent handlers
+ */
+export declare function onPaymentIntent(handlers: {
+  succeeded?: WebhookHandler
+  failed?: WebhookHandler
+  created?: WebhookHandler
+  canceled?: WebhookHandler
+}): void;
+/**
+ * Register subscription handlers
+ */
+export declare function onSubscription(handlers: {
+  created?: WebhookHandler
+  updated?: WebhookHandler
+  deleted?: WebhookHandler
+  trialWillEnd?: WebhookHandler
+}): void;
+/**
+ * Register invoice handlers
+ */
+export declare function onInvoice(handlers: {
+  paid?: WebhookHandler
+  paymentFailed?: WebhookHandler
+  created?: WebhookHandler
+  finalized?: WebhookHandler
+}): void;
+/**
+ * Register checkout session handlers
+ */
+export declare function onCheckout(handlers: {
+  completed?: WebhookHandler
+  expired?: WebhookHandler
+}): void;
+/**
+ * Register charge handlers
+ */
+export declare function onCharge(handlers: {
+  succeeded?: WebhookHandler
+  failed?: WebhookHandler
+  refunded?: WebhookHandler
+  disputed?: WebhookHandler
+}): void;
+/**
+ * Extract payment intent from event
+ */
+export declare function getPaymentIntent(event: Stripe.Event): Stripe.PaymentIntent | null;
+/**
+ * Extract subscription from event
+ */
+export declare function getSubscription(event: Stripe.Event): Stripe.Subscription | null;
+/**
+ * Extract invoice from event
+ */
+export declare function getInvoice(event: Stripe.Event): Stripe.Invoice | null;
+/**
+ * Extract checkout session from event
+ */
+export declare function getCheckoutSession(event: Stripe.Event): Stripe.Checkout.Session | null;
+/**
+ * Extract charge from event
+ */
+export declare function getCharge(event: Stripe.Event): Stripe.Charge | null;
+/**
+ * Extract customer from event
+ */
+export declare function getCustomer(event: Stripe.Event): Stripe.Customer | null;
+declare const handlers: Map<WebhookEventType, WebhookHandler[]>;
+export declare const manageWebhook: {
+  
+};
+export declare interface WebhookConfig {
+  secret: string
+  tolerance?: number
+}
+export type WebhookEventType = | 'payment_intent.succeeded'
+  | 'payment_intent.payment_failed'
+  | 'payment_intent.created'
+  | 'payment_intent.canceled'
+  | 'customer.subscription.created'
+  | 'customer.subscription.updated'
+  | 'customer.subscription.deleted'
+  | 'customer.subscription.trial_will_end'
+  | 'customer.created'
+  | 'customer.updated'
+  | 'customer.deleted'
+  | 'invoice.paid'
+  | 'invoice.payment_failed'
+  | 'invoice.finalized'
+  | 'invoice.created'
+  | 'checkout.session.completed'
+  | 'checkout.session.expired'
+  | 'charge.succeeded'
+  | 'charge.failed'
+  | 'charge.refunded'
+  | 'charge.dispute.created'
+  | 'charge.dispute.closed'
+  | 'payment_method.attached'
+  | 'payment_method.detached'
+  | 'setup_intent.succeeded'
+  | 'setup_intent.setup_failed'
+  | string;
+export type WebhookHandler = (_event: Stripe.Event) => Promise<void> | void;

package/dist/src/drivers/stripe.d.ts

@@ -0,0 +1,8 @@
+import Stripe from 'stripe';
+/**
+ * Lazy-initialized Stripe instance.
+ * Only throws when you actually try to use Stripe, not at module load time.
+ * This allows the payments package to be imported without a configured key
+ * (e.g., in tests, CLI, or environments that don't use Stripe).
+ */
+export declare const stripe: Stripe;

package/dist/src/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Payments Package
+ *
+ * Provides payment processing capabilities with Stripe integration.
+ */
+// Main Payment facade
+export * from './payment';
+export { default as Payment } from './payment';
+// Billable modules
+export * from './billable';
+// Stripe driver and SDK
+export * from './drivers/stripe';
+export * as Stripe from 'stripe';

package/dist/src/payment.d.ts

@@ -0,0 +1,147 @@
+import type { UserModel } from '@stacksjs/orm';
+import type Stripe from 'stripe';
+/**
+ * Create a one-time charge
+ */
+export declare function charge(user: UserModel, amount: number, paymentMethod: string, options?: Partial<Stripe.PaymentIntentCreateParams>): Promise<Stripe.PaymentIntent>;
+/**
+ * Create a payment intent (for client-side confirmation)
+ */
+export declare function createPayment(user: UserModel, amount: number, options?: Partial<Stripe.PaymentIntentCreateParams>): Promise<Stripe.PaymentIntent>;
+/**
+ * Refund a payment
+ */
+export declare function refund(paymentIntentId: string, amount?: number, options?: Partial<Stripe.RefundCreateParams>): Promise<Stripe.Refund>;
+/**
+ * Create a Stripe Checkout session
+ */
+export declare function checkout(user: UserModel, lineItems: Stripe.Checkout.SessionCreateParams.LineItem[], options?: Partial<Stripe.Checkout.SessionCreateParams>): Promise<Stripe.Checkout.Session>;
+/**
+ * Create a subscription checkout session
+ */
+export declare function subscriptionCheckout(user: UserModel, priceId: string, options?: Partial<Stripe.Checkout.SessionCreateParams>): Promise<Stripe.Checkout.Session>;
+/**
+ * Create a new subscription
+ */
+export declare function subscribe(user: UserModel, lookupKey: string, options?: Partial<Stripe.SubscriptionCreateParams>): Promise<Stripe.Subscription>;
+/**
+ * Cancel a subscription
+ */
+export declare function cancelSubscription(subscriptionId: string, immediately?: boolean): Promise<Stripe.Subscription>;
+/**
+ * Check if user has an active subscription
+ */
+export declare function hasActiveSubscription(user: UserModel, type?: string): Promise<boolean>;
+/**
+ * Update subscription to a new price
+ */
+export declare function changeSubscription(user: UserModel, newLookupKey: string, type?: string): Promise<Stripe.Subscription>;
+/**
+ * Get or create a Stripe customer for a user
+ */
+export declare function getOrCreateCustomer(user: UserModel, options?: Stripe.CustomerCreateParams): Promise<Stripe.Customer>;
+/**
+ * Update customer details
+ */
+export declare function updateCustomer(user: UserModel, options: Stripe.CustomerCreateParams): Promise<Stripe.Customer>;
+/**
+ * Delete a customer from Stripe
+ */
+export declare function deleteCustomer(user: UserModel): Promise<Stripe.DeletedCustomer>;
+/**
+ * Add a payment method to a customer
+ */
+export declare function addPaymentMethod(user: UserModel, paymentMethodId: string): Promise<Stripe.PaymentMethod>;
+/**
+ * Set the default payment method
+ */
+export declare function setDefaultPaymentMethod(user: UserModel, paymentMethodId: string): Promise<Stripe.Customer>;
+/**
+ * Remove a payment method.
+ * Accepts either a numeric database ID or a Stripe payment method ID string (pm_xxx).
+ */
+export declare function removePaymentMethod(user: UserModel, paymentMethodId: string | number): Promise<Stripe.PaymentMethod>;
+/**
+ * Create a setup intent for adding payment methods
+ */
+export declare function createSetupIntent(user: UserModel, options?: Partial<Stripe.SetupIntentCreateParams>): Promise<Stripe.SetupIntent>;
+/**
+ * Get user's invoices
+ */
+export declare function getInvoices(user: UserModel): Promise<Stripe.ApiList<Stripe.Invoice>>;
+/**
+ * Create an invoice
+ */
+export declare function createInvoice(customerId: string, options?: Partial<Stripe.InvoiceCreateParams>): Promise<Stripe.Invoice>;
+/**
+ * Pay an invoice
+ */
+export declare function payInvoice(invoiceId: string): Promise<Stripe.Invoice>;
+/**
+ * Create a product with a price
+ */
+export declare function createProduct(name: string, price: number, options?: {
+    currency?: string
+    interval?: 'day' | 'week' | 'month' | 'year'
+    description?: string
+    metadata?: Stripe.MetadataParam
+  }): Promise<{ product: Stripe.Product, price: Stripe.Price }>;
+/**
+ * Get a price by lookup key
+ */
+export declare function getPrice(lookupKey: string): Promise<Stripe.Price | undefined>;
+/**
+ * List all products
+ */
+export declare function listProducts(options?: Stripe.ProductListParams): Promise<Stripe.ApiList<Stripe.Product>>;
+/**
+ * Create a discount coupon
+ */
+export declare function createCoupon(options: {
+    percentOff?: number
+    amountOff?: number
+    currency?: string
+    duration?: 'forever' | 'once' | 'repeating'
+    durationInMonths?: number
+    name?: string
+    maxRedemptions?: number
+  }): Promise<Stripe.Coupon>;
+/**
+ * Create a promotion code from a coupon
+ */
+export declare function createPromoCode(couponId: string, code: string, options?: Partial<Stripe.PromotionCodeCreateParams>): Promise<Stripe.PromotionCode>;
+/**
+ * Validate a promo code
+ */
+export declare function validatePromoCode(code: string): Promise<Stripe.PromotionCode | null>;
+/**
+ * Format amount for display.
+ *
+ * Currency defaults to the project's configured payment currency
+ * (`config.payment.currency` / `STRIPE_CURRENCY`), falling back to USD only
+ * when nothing else is set. Locale follows the same pattern via
+ * `config.app.locale` so EU merchants see €1.234,56 not $1,234.56.
+ */
+export declare function formatAmount(amount: number, currency?: string): string;
+/**
+ * Convert dollars to cents
+ */
+export declare function toCents(dollars: number): number;
+/**
+ * Convert cents to dollars
+ */
+export declare function toDollars(cents: number): number;
+// =============================================================================
+// Payment Facade Object
+// =============================================================================
+export declare const Payment: {
+  webhook: unknown;
+  customer: unknown;
+  subscription: unknown;
+  invoice: unknown;
+  paymentMethod: unknown;
+  product: unknown;
+  price: unknown;
+  coupon: unknown
+};
+export default Payment;

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@stacksjs/payments",
   "type": "module",
-  "version": "0.70.23",
+  "version": "0.70.26",
   "description": "The Stacks payments package. Currently supporting Stripe.",
   "author": "Chris Breuer",
-  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
+  "contributors": [
+    "Chris Breuer <chris@stacksjs.com>"
+  ],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/payments#readme",
@@ -27,26 +29,31 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
       "import": "./dist/index.js"
     },
     "./*": {
+      "bun": "./src/*",
       "import": "./dist/*"
     }
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["README.md", "dist"],
+  "files": [
+    "README.md",
+    "dist"
+  ],
   "scripts": {
     "build": "bun build.ts",
     "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/config": "0.70.22",
-    "@stacksjs/development": "0.70.22",
-    "@stacksjs/utils": "0.70.22",
-    "@stripe/stripe-js": "^6.1.0",
-    "@vue-stripe/vue-stripe": "^4.5.0",
-    "stripe": "^17.7.0"
+    "@stacksjs/config": "0.70.23",
+    "better-dx": "^0.2.12",
+    "@stacksjs/utils": "0.70.23",
+    "@stripe/stripe-js": "^8.7.0",
+    "stripe": "^21.0.1"
   }
 }

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export * from './billable'
-export * as stripe from './drivers/stripe'
-export * from 'stripe'

package/dist/invoice.d.ts

@@ -1,6 +0,0 @@
-import type { UserModel } from '../../../../orm/src/models/User';
-
-export declare interface ManageInvoice {
-  list: (user: UserModel) => Promise<Stripe.Response<Stripe.ApiList<Stripe.Invoice>>>
-}
-export declare const manageInvoice: ManageInvoice;

package/dist/setup-products.d.ts

@@ -1,12 +0,0 @@
-import type { Err } from '@stacksjs/error-handling';
-
-declare interface PriceParams {
-  unit_amount: number
-  currency: string
-  product: string
-  lookup_key: string
-  recurring?: {
-    interval: 'day' | 'month' | 'week' | 'year'
-  }
-}
-export declare function createStripeProduct(): Promise<Ok<string, never> | Err<string, any>>;