@vynxc/better-stripe 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1388 @@
+import * as better_auth from 'better-auth';
+import { User, GenericEndpointContext, Session, InferOptionSchema } from 'better-auth';
+import { Organization } from 'better-auth/plugins/organization';
+import Stripe from 'stripe';
+import * as zod from 'zod';
+import * as better_call from 'better-call';
+
+declare const subscriptions: {
+    subscription: {
+        fields: {
+            plan: {
+                type: "string";
+                required: true;
+            };
+            referenceId: {
+                type: "string";
+                required: true;
+            };
+            stripeCustomerId: {
+                type: "string";
+                required: false;
+            };
+            stripeSubscriptionId: {
+                type: "string";
+                required: false;
+            };
+            status: {
+                type: "string";
+                defaultValue: string;
+            };
+            periodStart: {
+                type: "date";
+                required: false;
+            };
+            periodEnd: {
+                type: "date";
+                required: false;
+            };
+            trialStart: {
+                type: "date";
+                required: false;
+            };
+            trialEnd: {
+                type: "date";
+                required: false;
+            };
+            cancelAtPeriodEnd: {
+                type: "boolean";
+                required: false;
+                defaultValue: false;
+            };
+            cancelAt: {
+                type: "date";
+                required: false;
+            };
+            canceledAt: {
+                type: "date";
+                required: false;
+            };
+            endedAt: {
+                type: "date";
+                required: false;
+            };
+            seats: {
+                type: "number";
+                required: false;
+            };
+            billingInterval: {
+                type: "string";
+                required: false;
+            };
+            stripeScheduleId: {
+                type: "string";
+                required: false;
+            };
+        };
+    };
+};
+declare const payments: {
+    payment: {
+        fields: {
+            product: {
+                type: "string";
+                required: true;
+            };
+            referenceId: {
+                type: "string";
+                required: true;
+            };
+            stripeCustomerId: {
+                type: "string";
+                required: false;
+            };
+            stripeSessionId: {
+                type: "string";
+                required: false;
+            };
+            stripePaymentIntentId: {
+                type: "string";
+                required: false;
+            };
+            priceId: {
+                type: "string";
+                required: false;
+            };
+            status: {
+                type: "string";
+                defaultValue: string;
+            };
+            amount: {
+                type: "number";
+                required: false;
+            };
+            currency: {
+                type: "string";
+                required: false;
+                defaultValue: string;
+            };
+            metadata: {
+                type: "string";
+                required: false;
+            };
+        };
+    };
+};
+declare const user: {
+    user: {
+        fields: {
+            stripeCustomerId: {
+                type: "string";
+                required: false;
+            };
+        };
+    };
+};
+declare const organization: {
+    organization: {
+        fields: {
+            stripeCustomerId: {
+                type: "string";
+                required: false;
+            };
+        };
+    };
+};
+
+type AuthorizeReferenceAction = SubscriptionAction | PaymentAction;
+type SubscriptionAction = "upgrade-subscription" | "list-subscription" | "cancel-subscription" | "restore-subscription" | "billing-portal";
+type PaymentAction = "create-payment" | "view-payment" | "list-payments";
+type CustomerType = "user" | "organization";
+type WithStripeCustomerId = {
+    stripeCustomerId?: string;
+};
+type WithActiveOrganizationId = {
+    activeOrganizationId?: string;
+};
+type StripeCtxSession = {
+    session: Session & WithActiveOrganizationId;
+    user: User & WithStripeCustomerId;
+};
+type StripePlan = {
+    /**
+     * Monthly price id
+     */
+    priceId?: string | undefined;
+    /**
+     * To use lookup key instead of price id
+     *
+     * https://docs.stripe.com/products-prices/
+     * manage-prices#lookup-keys
+     */
+    lookupKey?: string | undefined;
+    /**
+     * A yearly discount price id
+     *
+     * useful when you want to offer a discount for
+     * yearly subscription
+     */
+    annualDiscountPriceId?: string | undefined;
+    /**
+     * To use lookup key instead of price id
+     *
+     * https://docs.stripe.com/products-prices/
+     * manage-prices#lookup-keys
+     */
+    annualDiscountLookupKey?: string | undefined;
+    /**
+     * Plan name
+     */
+    name: string;
+    /**
+     * Limits for the plan
+     *
+     * useful when you want to define plan-specific metadata.
+     */
+    limits?: Record<string, unknown> | undefined;
+    /**
+     * Plan group name
+     *
+     * useful when you want to group plans or
+     * when a user can subscribe to multiple plans.
+     */
+    group?: string | undefined;
+    /**
+     * Per-seat billing price ID
+     *
+     * Requires the `organization` plugin. Member changes
+     * automatically sync the seat quantity in Stripe.
+     */
+    seatPriceId?: string | undefined;
+    /**
+     * Proration behavior when updating this plan's subscription.
+     *
+     * Controls how Stripe handles mid-cycle price changes.
+     * - `create_prorations`: Add proration line items to the next invoice (default)
+     * - `always_invoice`: Create prorations and immediately invoice
+     * - `none`: No proration; new price applies at next billing cycle
+     *
+     * @default "create_prorations"
+     * @see https://docs.stripe.com/billing/subscriptions/prorations
+     */
+    prorationBehavior?: Stripe.SubscriptionUpdateParams.ProrationBehavior | undefined;
+    /**
+     * Additional line items to include in the checkout session.
+     *
+     * All line items must use the same billing interval as the base price (e.g. all monthly or all yearly).
+     * Stripe does not support mixed-interval subscriptions via Checkout Sessions.
+     *
+     * @see https://docs.stripe.com/billing/subscriptions/mixed-interval#limitations
+     */
+    lineItems?: Stripe.Checkout.SessionCreateParams.LineItem[] | undefined;
+    /**
+     * Free trial days
+     */
+    freeTrial?: {
+        /**
+         * Number of days
+         */
+        days: number;
+        /**
+         * A function that will be called when the trial
+         * starts.
+         *
+         * @param subscription
+         * @returns
+         */
+        onTrialStart?: (subscription: Subscription) => Promise<void>;
+        /**
+         * A function that will be called when the trial
+         * ends
+         *
+         * @param subscription - Subscription
+         * @returns
+         */
+        onTrialEnd?: (data: {
+            subscription: Subscription;
+        }, ctx: GenericEndpointContext) => Promise<void>;
+        /**
+         * A function that will be called when the trial
+         * expired.
+         * @param subscription - Subscription
+         * @returns
+         */
+        onTrialExpired?: (subscription: Subscription, ctx: GenericEndpointContext) => Promise<void>;
+    } | undefined;
+};
+interface Subscription {
+    /**
+     * Database identifier
+     */
+    id: string;
+    /**
+     * The plan name
+     */
+    plan: string;
+    /**
+     * Stripe customer id
+     */
+    stripeCustomerId?: string | undefined;
+    /**
+     * Stripe subscription id
+     */
+    stripeSubscriptionId?: string | undefined;
+    /**
+     * Trial start date
+     */
+    trialStart?: Date | undefined;
+    /**
+     * Trial end date
+     */
+    trialEnd?: Date | undefined;
+    /**
+     * Price Id for the subscription
+     */
+    priceId?: string | undefined;
+    /**
+     * To what reference id the subscription belongs to
+     * @example
+     * - userId for a user
+     * - workspace id for a saas platform
+     * - website id for a hosting platform
+     *
+     * @default - userId
+     */
+    referenceId: string;
+    /**
+     * Subscription status
+     */
+    status: "active" | "canceled" | "incomplete" | "incomplete_expired" | "past_due" | "paused" | "trialing" | "unpaid";
+    /**
+     * The billing cycle start date
+     */
+    periodStart?: Date | undefined;
+    /**
+     * The billing cycle end date
+     */
+    periodEnd?: Date | undefined;
+    /**
+     * Whether this subscription will (if status=active)
+     * or did (if status=canceled) cancel at the end of the current billing period.
+     */
+    cancelAtPeriodEnd?: boolean | undefined;
+    /**
+     * If the subscription is scheduled to be canceled,
+     * this is the time at which the cancellation will take effect.
+     */
+    cancelAt?: Date | undefined;
+    /**
+     * If the subscription has been canceled, this is the time when it was canceled.
+     *
+     * Note: If the subscription was canceled with `cancel_at_period_end`,
+     * this reflects the cancellation request time, not when the subscription actually ends.
+     */
+    canceledAt?: Date | undefined;
+    /**
+     * If the subscription has ended, the date the subscription ended.
+     */
+    endedAt?: Date | undefined;
+    /**
+     * A field to group subscriptions so you can have multiple subscriptions
+     * for one reference id
+     */
+    groupId?: string | undefined;
+    /**
+     * Number of seats for the subscription (useful for team plans)
+     */
+    seats?: number | undefined;
+    /**
+     * The billing interval for this subscription.
+     * Indicates how often the subscription is billed.
+     * @see https://docs.stripe.com/api/plans/object#plan_object-interval
+     */
+    billingInterval?: "day" | "week" | "month" | "year" | undefined;
+    /**
+     * Stripe Subscription Schedule ID, present when a scheduled
+     * plan change is pending for this subscription.
+     */
+    stripeScheduleId?: string | undefined;
+}
+type StripeProduct = {
+    /**
+     * Product price id
+     */
+    priceId?: string;
+    /**
+     * To use lookup key instead of price id
+     *
+     * https://docs.stripe.com/products-prices/manage-prices#lookup-keys
+     */
+    lookupKey?: string;
+    /**
+     * Product name
+     */
+    name: string;
+    /**
+     * Product description
+     */
+    description?: string;
+    /**
+     * Product group name
+     *
+     * useful when you want to group products or
+     * categorize different types of payments
+     */
+    group?: string;
+    /**
+     * Product metadata
+     */
+    metadata?: Record<string, any>;
+    /**
+     * A callback to run after a payment is completed
+     */
+    onPaymentComplete?: (data: {
+        event: Stripe.Event;
+        stripeSession: Stripe.Checkout.Session;
+        payment: Payment;
+        product: StripeProduct;
+    }, ctx: GenericEndpointContext) => Promise<void>;
+};
+interface Payment {
+    /**
+     * Database identifier
+     */
+    id: string;
+    /**
+     * The product name
+     */
+    product: string;
+    /**
+     * Stripe customer id
+     */
+    stripeCustomerId?: string;
+    /**
+     * Stripe checkout session id
+     */
+    stripeSessionId?: string;
+    /**
+     * Stripe payment intent id
+     */
+    stripePaymentIntentId?: string;
+    /**
+     * Price Id for the payment
+     */
+    priceId?: string;
+    /**
+     * To what reference id the payment belongs to
+     * @example
+     * - userId for a user
+     * - workspace id for a saas platform
+     * - website id for a hosting platform
+     *
+     * @default - userId
+     */
+    referenceId: string;
+    /**
+     * Payment status
+     */
+    status: "requires_payment_method" | "requires_confirmation" | "requires_action" | "processing" | "requires_capture" | "canceled" | "succeeded";
+    /**
+     * Amount paid (in cents)
+     */
+    amount?: number;
+    /**
+     * Currency code
+     */
+    currency?: string;
+    /**
+     * Additional metadata
+     */
+    metadata?: string;
+}
+interface InputPayment extends Omit<Payment, "id"> {
+}
+type SubscriptionOptions = {
+    /**
+     * Subscription Configuration
+     */
+    /**
+     * List of plan
+     */
+    plans: StripePlan[] | (() => StripePlan[] | Promise<StripePlan[]>);
+    /**
+     * Require email verification before a user is allowed to upgrade
+     * their subscriptions
+     *
+     * @default false
+     */
+    requireEmailVerification?: boolean | undefined;
+    /**
+     * A callback to run after a user has subscribed to a package
+     * @param event - Stripe Event
+     * @param subscription - Subscription Data
+     * @returns
+     */
+    onSubscriptionComplete?: ((data: {
+        event: Stripe.Event;
+        stripeSubscription: Stripe.Subscription;
+        subscription: Subscription;
+        plan: StripePlan;
+    }, ctx: GenericEndpointContext) => Promise<void>) | undefined;
+    /**
+     * A callback to run after a user is about to cancel their subscription
+     * @returns
+     */
+    onSubscriptionUpdate?: ((data: {
+        event: Stripe.Event;
+        subscription: Subscription;
+    }) => Promise<void>) | undefined;
+    /**
+     * A callback to run after a user is about to cancel their subscription
+     * @returns
+     */
+    onSubscriptionCancel?: ((data: {
+        event?: Stripe.Event;
+        subscription: Subscription;
+        stripeSubscription: Stripe.Subscription;
+        cancellationDetails?: Stripe.Subscription.CancellationDetails | null;
+    }) => Promise<void>) | undefined;
+    /**
+     * A function to check if the reference id is valid
+     * and belongs to the user
+     *
+     * @param data - data containing user, session and referenceId
+     * @param ctx - the context object
+     * @returns
+     */
+    authorizeReference?: ((data: {
+        user: User & Record<string, any>;
+        session: Session & Record<string, any>;
+        referenceId: string;
+        action: AuthorizeReferenceAction;
+    }, ctx: GenericEndpointContext) => Promise<boolean>) | undefined;
+    /**
+     * A callback to run after a user has deleted their subscription
+     * @returns
+     */
+    onSubscriptionDeleted?: ((data: {
+        event: Stripe.Event;
+        stripeSubscription: Stripe.Subscription;
+        subscription: Subscription;
+    }) => Promise<void>) | undefined;
+    /**
+     * A callback to run when a subscription is created
+     * @returns
+     */
+    onSubscriptionCreated?: ((data: {
+        event: Stripe.Event;
+        stripeSubscription: Stripe.Subscription;
+        subscription: Subscription;
+        plan: StripePlan;
+    }) => Promise<void>) | undefined;
+    /**
+     * parameters for session create params
+     *
+     * @param data - data containing user, session and plan
+     * @param req - the request object
+     * @param ctx - the context object
+     */
+    getCheckoutSessionParams?: ((data: {
+        user: User & Record<string, any>;
+        session: Session & Record<string, any>;
+        plan: StripePlan;
+        subscription: Subscription;
+    }, req: GenericEndpointContext["request"], ctx: GenericEndpointContext) => Promise<{
+        params?: Stripe.Checkout.SessionCreateParams;
+        options?: Stripe.RequestOptions;
+    }> | {
+        params?: Stripe.Checkout.SessionCreateParams;
+        options?: Stripe.RequestOptions;
+    }) | undefined;
+};
+interface StripeOptions {
+    /**
+     * Stripe Client
+     */
+    stripeClient: Stripe;
+    /**
+     * Stripe Webhook Secret
+     *
+     * @description Stripe webhook secret key
+     */
+    stripeWebhookSecret: string;
+    /**
+     * Enable customer creation when a user signs up
+     */
+    createCustomerOnSignUp?: boolean | undefined;
+    /**
+     * A callback to run after a customer has been created
+     * @param customer - Customer Data
+     * @param stripeCustomer - Stripe Customer Data
+     * @returns
+     */
+    onCustomerCreate?: ((data: {
+        stripeCustomer: Stripe.Customer;
+        user: User & WithStripeCustomerId;
+    }, ctx: GenericEndpointContext) => Promise<void>) | undefined;
+    /**
+     * A custom function to get the customer create
+     * params
+     * @param data - data containing user and session
+     * @returns
+     */
+    getCustomerCreateParams?: ((user: User, ctx: GenericEndpointContext) => Promise<Partial<Stripe.CustomerCreateParams>>) | undefined;
+    /**
+     * Subscriptions
+     */
+    subscription?: ({
+        enabled: false;
+    } | ({
+        enabled: true;
+    } & SubscriptionOptions)) | undefined;
+    /**
+     * One-time payments
+     */
+    payments?: {
+        enabled: boolean;
+        /**
+         * List of products available for one-time purchase
+         */
+        products: StripeProduct[] | (() => StripeProduct[] | Promise<StripeProduct[]>);
+        /**
+         * Require email verification before a user is allowed to make payments
+         *
+         * @default false
+         */
+        requireEmailVerification?: boolean;
+        /**
+         * Default success URL for checkout sessions
+         */
+        successUrl?: string;
+        /**
+         * Default cancel URL for checkout sessions
+         */
+        cancelUrl?: string;
+        /**
+         * Allow promotion codes in checkout
+         *
+         * @default false
+         */
+        allowPromotionCodes?: boolean;
+        /**
+         * Enable automatic tax calculation
+         *
+         * @default false
+         */
+        automaticTax?: boolean;
+        /**
+         * A function to check if the reference id is valid
+         * and belongs to the user
+         */
+        authorizeReference?: (data: {
+            user: User & Record<string, any>;
+            session: Session & Record<string, any>;
+            referenceId: string;
+            action: PaymentAction;
+        }, ctx: GenericEndpointContext) => Promise<boolean>;
+        /**
+         * Custom parameters for checkout session creation
+         */
+        getCheckoutSessionParams?: (data: {
+            user: User & Record<string, any>;
+            session: Session & Record<string, any>;
+            product: StripeProduct;
+            payment: Payment;
+        }, ctx: GenericEndpointContext) => Promise<{
+            params?: Stripe.Checkout.SessionCreateParams;
+            options?: Stripe.RequestOptions;
+        }> | {
+            params?: Stripe.Checkout.SessionCreateParams;
+            options?: Stripe.RequestOptions;
+        };
+    } | undefined;
+    /**
+     * Organization Stripe integration
+     *
+     * Enable organizations to have their own Stripe customer ID
+     */
+    organization?: {
+        /**
+         * Enable organization Stripe customer
+         */
+        enabled: true;
+        /**
+         * A custom function to get the customer create params
+         * for organization customers.
+         *
+         * @param organization - the organization
+         * @param ctx - the context object
+         * @returns
+         */
+        getCustomerCreateParams?: ((organization: Organization, ctx: GenericEndpointContext) => Promise<Partial<Stripe.CustomerCreateParams>>) | undefined;
+        /**
+         * A callback to run after an organization customer has been created
+         *
+         * @param data - data containing stripeCustomer and organization
+         * @param ctx - the context object
+         * @returns
+         */
+        onCustomerCreate?: ((data: {
+            stripeCustomer: Stripe.Customer;
+            organization: Organization & WithStripeCustomerId;
+        }, ctx: GenericEndpointContext) => Promise<void>) | undefined;
+    } | undefined;
+    /**
+     * A callback to run after a stripe event is received
+     * @param event - Stripe Event
+     * @returns
+     */
+    onEvent?: ((event: Stripe.Event) => Promise<void>) | undefined;
+    /**
+     * Schema for the stripe plugin
+     */
+    schema?: InferOptionSchema<typeof subscriptions & typeof user & typeof organization & typeof payments> | undefined;
+}
+
+declare module "@better-auth/core" {
+    interface BetterAuthPluginRegistry<AuthOptions, Options> {
+        stripe: {
+            creator: typeof stripe;
+        };
+    }
+}
+declare const stripe: <O extends StripeOptions>(options: O) => {
+    id: "stripe";
+    endpoints: {
+        stripeWebhook: better_call.StrictEndpoint<"/stripe/webhook", {
+            method: "POST";
+            metadata: {
+                openapi: {
+                    operationId: string;
+                };
+                scope: "server";
+            };
+            cloneRequest: true;
+            disableBody: true;
+        }, {
+            success: boolean;
+        }>;
+    } & (O["subscription"] extends {
+        enabled: true;
+    } ? {
+        upgradeSubscription: better_call.StrictEndpoint<"/subscription/upgrade", {
+            method: "POST";
+            body: zod.ZodObject<{
+                plan: zod.ZodString;
+                annual: zod.ZodOptional<zod.ZodBoolean>;
+                referenceId: zod.ZodOptional<zod.ZodString>;
+                subscriptionId: zod.ZodOptional<zod.ZodString>;
+                customerType: zod.ZodOptional<zod.ZodEnum<{
+                    organization: "organization";
+                    user: "user";
+                }>>;
+                metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
+                seats: zod.ZodOptional<zod.ZodNumber>;
+                locale: zod.ZodOptional<zod.ZodCustom<Stripe.Checkout.Session.Locale, Stripe.Checkout.Session.Locale>>;
+                successUrl: zod.ZodDefault<zod.ZodString>;
+                cancelUrl: zod.ZodDefault<zod.ZodString>;
+                returnUrl: zod.ZodOptional<zod.ZodString>;
+                scheduleAtPeriodEnd: zod.ZodDefault<zod.ZodBoolean>;
+                disableRedirect: zod.ZodDefault<zod.ZodBoolean>;
+            }, better_auth.$strip>;
+            metadata: {
+                openapi: {
+                    operationId: string;
+                };
+            };
+            use: (((inputContext: better_call.MiddlewareInputContext<{
+                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+            }>) => Promise<{
+                session: StripeCtxSession;
+            }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<void>))[];
+        }, {
+            url: string;
+            redirect: boolean;
+        } | {
+            redirect: boolean;
+            id: string;
+            object: "checkout.session";
+            adaptive_pricing: Stripe.Checkout.Session.AdaptivePricing | null;
+            after_expiration: Stripe.Checkout.Session.AfterExpiration | null;
+            allow_promotion_codes: boolean | null;
+            amount_subtotal: number | null;
+            amount_total: number | null;
+            automatic_tax: Stripe.Checkout.Session.AutomaticTax;
+            billing_address_collection: Stripe.Checkout.Session.BillingAddressCollection | null;
+            branding_settings?: Stripe.Checkout.Session.BrandingSettings;
+            cancel_url: string | null;
+            client_reference_id: string | null;
+            client_secret: string | null;
+            collected_information: Stripe.Checkout.Session.CollectedInformation | null;
+            consent: Stripe.Checkout.Session.Consent | null;
+            consent_collection: Stripe.Checkout.Session.ConsentCollection | null;
+            created: number;
+            currency: string | null;
+            currency_conversion: Stripe.Checkout.Session.CurrencyConversion | null;
+            custom_fields: Array<Stripe.Checkout.Session.CustomField>;
+            custom_text: Stripe.Checkout.Session.CustomText;
+            customer: string | Stripe.Customer | Stripe.DeletedCustomer | null;
+            customer_account: string | null;
+            customer_creation: Stripe.Checkout.Session.CustomerCreation | null;
+            customer_details: Stripe.Checkout.Session.CustomerDetails | null;
+            customer_email: string | null;
+            discounts: Array<Stripe.Checkout.Session.Discount> | null;
+            excluded_payment_method_types?: Array<string>;
+            expires_at: number;
+            invoice: string | Stripe.Invoice | null;
+            invoice_creation: Stripe.Checkout.Session.InvoiceCreation | null;
+            line_items?: Stripe.ApiList<Stripe.LineItem>;
+            livemode: boolean;
+            locale: Stripe.Checkout.Session.Locale | null;
+            metadata: Stripe.Metadata | null;
+            mode: Stripe.Checkout.Session.Mode;
+            name_collection?: Stripe.Checkout.Session.NameCollection;
+            optional_items?: Array<Stripe.Checkout.Session.OptionalItem> | null;
+            origin_context: Stripe.Checkout.Session.OriginContext | null;
+            payment_intent: string | Stripe.PaymentIntent | null;
+            payment_link: string | Stripe.PaymentLink | null;
+            payment_method_collection: Stripe.Checkout.Session.PaymentMethodCollection | null;
+            payment_method_configuration_details: Stripe.Checkout.Session.PaymentMethodConfigurationDetails | null;
+            payment_method_options: Stripe.Checkout.Session.PaymentMethodOptions | null;
+            payment_method_types: Array<string>;
+            payment_status: Stripe.Checkout.Session.PaymentStatus;
+            permissions: Stripe.Checkout.Session.Permissions | null;
+            phone_number_collection?: Stripe.Checkout.Session.PhoneNumberCollection;
+            presentment_details?: Stripe.Checkout.Session.PresentmentDetails;
+            recovered_from: string | null;
+            redirect_on_completion?: Stripe.Checkout.Session.RedirectOnCompletion;
+            return_url?: string;
+            saved_payment_method_options: Stripe.Checkout.Session.SavedPaymentMethodOptions | null;
+            setup_intent: string | Stripe.SetupIntent | null;
+            shipping_address_collection: Stripe.Checkout.Session.ShippingAddressCollection | null;
+            shipping_cost: Stripe.Checkout.Session.ShippingCost | null;
+            shipping_options: Array<Stripe.Checkout.Session.ShippingOption>;
+            status: Stripe.Checkout.Session.Status | null;
+            submit_type: Stripe.Checkout.Session.SubmitType | null;
+            subscription: string | Stripe.Subscription | null;
+            success_url: string | null;
+            tax_id_collection?: Stripe.Checkout.Session.TaxIdCollection;
+            total_details: Stripe.Checkout.Session.TotalDetails | null;
+            ui_mode: Stripe.Checkout.Session.UiMode | null;
+            url: string | null;
+            wallet_options: Stripe.Checkout.Session.WalletOptions | null;
+            lastResponse: {
+                headers: {
+                    [key: string]: string;
+                };
+                requestId: string;
+                statusCode: number;
+                apiVersion?: string;
+                idempotencyKey?: string;
+                stripeAccount?: string;
+            };
+        }>;
+        cancelSubscription: better_call.StrictEndpoint<"/subscription/cancel", {
+            method: "POST";
+            body: zod.ZodObject<{
+                referenceId: zod.ZodOptional<zod.ZodString>;
+                subscriptionId: zod.ZodOptional<zod.ZodString>;
+                customerType: zod.ZodOptional<zod.ZodEnum<{
+                    organization: "organization";
+                    user: "user";
+                }>>;
+                returnUrl: zod.ZodString;
+                disableRedirect: zod.ZodDefault<zod.ZodBoolean>;
+            }, better_auth.$strip>;
+            metadata: {
+                openapi: {
+                    operationId: string;
+                };
+            };
+            use: (((inputContext: better_call.MiddlewareInputContext<{
+                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+            }>) => Promise<{
+                session: StripeCtxSession;
+            }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<void>))[];
+        }, {
+            url: string;
+            redirect: boolean;
+        }>;
+        restoreSubscription: better_call.StrictEndpoint<"/subscription/restore", {
+            method: "POST";
+            body: zod.ZodObject<{
+                referenceId: zod.ZodOptional<zod.ZodString>;
+                subscriptionId: zod.ZodOptional<zod.ZodString>;
+                customerType: zod.ZodOptional<zod.ZodEnum<{
+                    organization: "organization";
+                    user: "user";
+                }>>;
+            }, better_auth.$strip>;
+            metadata: {
+                openapi: {
+                    operationId: string;
+                };
+            };
+            use: (((inputContext: better_call.MiddlewareInputContext<{
+                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+            }>) => Promise<{
+                session: StripeCtxSession;
+            }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<void>))[];
+        }, Stripe.Response<Stripe.Subscription>>;
+        listActiveSubscriptions: better_call.StrictEndpoint<"/subscription/list", {
+            method: "GET";
+            query: zod.ZodOptional<zod.ZodObject<{
+                referenceId: zod.ZodOptional<zod.ZodString>;
+                customerType: zod.ZodOptional<zod.ZodEnum<{
+                    organization: "organization";
+                    user: "user";
+                }>>;
+            }, better_auth.$strip>>;
+            metadata: {
+                openapi: {
+                    operationId: string;
+                };
+            };
+            use: (((inputContext: better_call.MiddlewareInputContext<{
+                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+            }>) => Promise<{
+                session: StripeCtxSession;
+            }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<void>))[];
+        }, {
+            limits: Record<string, unknown> | undefined;
+            priceId: string | undefined;
+            id: string;
+            plan: string;
+            stripeCustomerId?: string | undefined;
+            stripeSubscriptionId?: string | undefined;
+            trialStart?: Date | undefined;
+            trialEnd?: Date | undefined;
+            referenceId: string;
+            status: "active" | "canceled" | "incomplete" | "incomplete_expired" | "past_due" | "paused" | "trialing" | "unpaid";
+            periodStart?: Date | undefined;
+            periodEnd?: Date | undefined;
+            cancelAtPeriodEnd?: boolean | undefined;
+            cancelAt?: Date | undefined;
+            canceledAt?: Date | undefined;
+            endedAt?: Date | undefined;
+            groupId?: string | undefined;
+            seats?: number | undefined;
+            billingInterval?: "day" | "week" | "month" | "year" | undefined;
+            stripeScheduleId?: string | undefined;
+        }[]>;
+        subscriptionSuccess: better_call.StrictEndpoint<"/subscription/success", {
+            method: "GET";
+            query: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
+            metadata: {
+                openapi: {
+                    operationId: string;
+                };
+            };
+            use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<void>)[];
+        }, never>;
+        createBillingPortal: better_call.StrictEndpoint<"/subscription/billing-portal", {
+            method: "POST";
+            body: zod.ZodObject<{
+                locale: zod.ZodOptional<zod.ZodCustom<Stripe.Checkout.Session.Locale, Stripe.Checkout.Session.Locale>>;
+                referenceId: zod.ZodOptional<zod.ZodString>;
+                customerType: zod.ZodOptional<zod.ZodEnum<{
+                    organization: "organization";
+                    user: "user";
+                }>>;
+                returnUrl: zod.ZodDefault<zod.ZodString>;
+                disableRedirect: zod.ZodDefault<zod.ZodBoolean>;
+            }, better_auth.$strip>;
+            metadata: {
+                openapi: {
+                    operationId: string;
+                };
+            };
+            use: (((inputContext: better_call.MiddlewareInputContext<{
+                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+            }>) => Promise<{
+                session: StripeCtxSession;
+            }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<void>))[];
+        }, {
+            url: string;
+            redirect: boolean;
+        }>;
+    } : {}) & (O["payments"] extends {
+        enabled: true;
+    } ? {
+        createPaymentSession: better_call.StrictEndpoint<"/payment/create-session", {
+            method: "POST";
+            body: zod.ZodObject<{
+                productName: zod.ZodString;
+                referenceId: zod.ZodOptional<zod.ZodString>;
+                quantity: zod.ZodDefault<zod.ZodNumber>;
+                successUrl: zod.ZodDefault<zod.ZodString>;
+                cancelUrl: zod.ZodDefault<zod.ZodString>;
+                disableRedirect: zod.ZodDefault<zod.ZodBoolean>;
+                metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
+            }, better_auth.$strip>;
+            metadata: {
+                openapi: {
+                    operationId: string;
+                };
+            };
+            use: (((inputContext: better_call.MiddlewareInputContext<{
+                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+            }>) => Promise<{
+                session: StripeCtxSession;
+            }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<void>))[];
+        }, {
+            url: string | null;
+            sessionId: string;
+            paymentId: string;
+            redirect: boolean;
+        }>;
+        getPaymentStatus: better_call.StrictEndpoint<"/payment/status", {
+            method: "GET";
+            query: zod.ZodOptional<zod.ZodObject<{
+                paymentId: zod.ZodOptional<zod.ZodString>;
+                sessionId: zod.ZodOptional<zod.ZodString>;
+                referenceId: zod.ZodOptional<zod.ZodString>;
+            }, better_auth.$strip>>;
+            metadata: {
+                openapi: {
+                    operationId: string;
+                };
+            };
+            use: (((inputContext: better_call.MiddlewareInputContext<{
+                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+            }>) => Promise<{
+                session: StripeCtxSession;
+            }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<void>))[];
+        }, Payment>;
+        listPayments: better_call.StrictEndpoint<"/payment/list", {
+            method: "GET";
+            query: zod.ZodOptional<zod.ZodObject<{
+                referenceId: zod.ZodOptional<zod.ZodString>;
+                status: zod.ZodOptional<zod.ZodString>;
+                limit: zod.ZodDefault<zod.ZodNumber>;
+                offset: zod.ZodDefault<zod.ZodNumber>;
+            }, better_auth.$strip>>;
+            metadata: {
+                openapi: {
+                    operationId: string;
+                };
+            };
+            use: (((inputContext: better_call.MiddlewareInputContext<{
+                use: ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+            }>) => Promise<{
+                session: StripeCtxSession;
+            }>) | ((inputContext: better_call.MiddlewareInputContext<better_call.MiddlewareOptions>) => Promise<void>))[];
+        }, Payment[]>;
+    } : {});
+    init(ctx: better_auth.AuthContext): {
+        options: {
+            databaseHooks: {
+                user: {
+                    create: {
+                        after(user: User & WithStripeCustomerId, ctx: better_auth.GenericEndpointContext | null): Promise<void>;
+                    };
+                    update: {
+                        after(user: User & WithStripeCustomerId, ctx: better_auth.GenericEndpointContext | null): Promise<void>;
+                    };
+                };
+            };
+        };
+    } | undefined;
+    schema: {
+        user: {
+            fields: {
+                stripeCustomerId: {
+                    type: "string";
+                    required: false;
+                };
+            };
+        };
+    } & (O["subscription"] extends {
+        enabled: true;
+    } ? {
+        subscription: {
+            fields: {
+                plan: {
+                    type: "string";
+                    required: true;
+                };
+                referenceId: {
+                    type: "string";
+                    required: true;
+                };
+                stripeCustomerId: {
+                    type: "string";
+                    required: false;
+                };
+                stripeSubscriptionId: {
+                    type: "string";
+                    required: false;
+                };
+                status: {
+                    type: "string";
+                    defaultValue: string;
+                };
+                periodStart: {
+                    type: "date";
+                    required: false;
+                };
+                periodEnd: {
+                    type: "date";
+                    required: false;
+                };
+                trialStart: {
+                    type: "date";
+                    required: false;
+                };
+                trialEnd: {
+                    type: "date";
+                    required: false;
+                };
+                cancelAtPeriodEnd: {
+                    type: "boolean";
+                    required: false;
+                    defaultValue: false;
+                };
+                cancelAt: {
+                    type: "date";
+                    required: false;
+                };
+                canceledAt: {
+                    type: "date";
+                    required: false;
+                };
+                endedAt: {
+                    type: "date";
+                    required: false;
+                };
+                seats: {
+                    type: "number";
+                    required: false;
+                };
+                billingInterval: {
+                    type: "string";
+                    required: false;
+                };
+                stripeScheduleId: {
+                    type: "string";
+                    required: false;
+                };
+            };
+        };
+    } : {}) & (O["organization"] extends {
+        enabled: true;
+    } ? {
+        organization: {
+            fields: {
+                stripeCustomerId: {
+                    type: "string";
+                    required: false;
+                };
+            };
+        };
+    } : {}) & (O["payments"] extends {
+        enabled: true;
+    } ? {
+        payment: {
+            fields: {
+                product: {
+                    type: "string";
+                    required: true;
+                };
+                referenceId: {
+                    type: "string";
+                    required: true;
+                };
+                stripeCustomerId: {
+                    type: "string";
+                    required: false;
+                };
+                stripeSessionId: {
+                    type: "string";
+                    required: false;
+                };
+                stripePaymentIntentId: {
+                    type: "string";
+                    required: false;
+                };
+                priceId: {
+                    type: "string";
+                    required: false;
+                };
+                status: {
+                    type: "string";
+                    defaultValue: string;
+                };
+                amount: {
+                    type: "number";
+                    required: false;
+                };
+                currency: {
+                    type: "string";
+                    required: false;
+                    defaultValue: string;
+                };
+                metadata: {
+                    type: "string";
+                    required: false;
+                };
+            };
+        };
+    } : {});
+    options: NoInfer<O>;
+    $ERROR_CODES: {
+        UNAUTHORIZED: better_auth.RawError<"UNAUTHORIZED">;
+        INVALID_REQUEST_BODY: better_auth.RawError<"INVALID_REQUEST_BODY">;
+        SUBSCRIPTION_NOT_FOUND: better_auth.RawError<"SUBSCRIPTION_NOT_FOUND">;
+        SUBSCRIPTION_PLAN_NOT_FOUND: better_auth.RawError<"SUBSCRIPTION_PLAN_NOT_FOUND">;
+        ALREADY_SUBSCRIBED_PLAN: better_auth.RawError<"ALREADY_SUBSCRIBED_PLAN">;
+        REFERENCE_ID_NOT_ALLOWED: better_auth.RawError<"REFERENCE_ID_NOT_ALLOWED">;
+        CUSTOMER_NOT_FOUND: better_auth.RawError<"CUSTOMER_NOT_FOUND">;
+        UNABLE_TO_CREATE_CUSTOMER: better_auth.RawError<"UNABLE_TO_CREATE_CUSTOMER">;
+        UNABLE_TO_CREATE_BILLING_PORTAL: better_auth.RawError<"UNABLE_TO_CREATE_BILLING_PORTAL">;
+        STRIPE_SIGNATURE_NOT_FOUND: better_auth.RawError<"STRIPE_SIGNATURE_NOT_FOUND">;
+        STRIPE_WEBHOOK_SECRET_NOT_FOUND: better_auth.RawError<"STRIPE_WEBHOOK_SECRET_NOT_FOUND">;
+        STRIPE_WEBHOOK_ERROR: better_auth.RawError<"STRIPE_WEBHOOK_ERROR">;
+        FAILED_TO_CONSTRUCT_STRIPE_EVENT: better_auth.RawError<"FAILED_TO_CONSTRUCT_STRIPE_EVENT">;
+        FAILED_TO_FETCH_PLANS: better_auth.RawError<"FAILED_TO_FETCH_PLANS">;
+        EMAIL_VERIFICATION_REQUIRED: better_auth.RawError<"EMAIL_VERIFICATION_REQUIRED">;
+        SUBSCRIPTION_NOT_ACTIVE: better_auth.RawError<"SUBSCRIPTION_NOT_ACTIVE">;
+        SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION: better_auth.RawError<"SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION">;
+        SUBSCRIPTION_NOT_PENDING_CHANGE: better_auth.RawError<"SUBSCRIPTION_NOT_PENDING_CHANGE">;
+        ORGANIZATION_NOT_FOUND: better_auth.RawError<"ORGANIZATION_NOT_FOUND">;
+        ORGANIZATION_SUBSCRIPTION_NOT_ENABLED: better_auth.RawError<"ORGANIZATION_SUBSCRIPTION_NOT_ENABLED">;
+        AUTHORIZE_REFERENCE_REQUIRED: better_auth.RawError<"AUTHORIZE_REFERENCE_REQUIRED">;
+        ORGANIZATION_HAS_ACTIVE_SUBSCRIPTION: better_auth.RawError<"ORGANIZATION_HAS_ACTIVE_SUBSCRIPTION">;
+        ORGANIZATION_REFERENCE_ID_REQUIRED: better_auth.RawError<"ORGANIZATION_REFERENCE_ID_REQUIRED">;
+        PRODUCT_NOT_FOUND: better_auth.RawError<"PRODUCT_NOT_FOUND">;
+        PAYMENT_NOT_FOUND: better_auth.RawError<"PAYMENT_NOT_FOUND">;
+    };
+};
+type StripePlugin<O extends StripeOptions> = ReturnType<typeof stripe<O>>;
+
+export { type AuthorizeReferenceAction, type CustomerType, type InputPayment, type Payment, type PaymentAction, type StripeCtxSession, type StripeOptions, type StripePlan, type StripePlugin, type StripeProduct, type Subscription, type SubscriptionAction, type SubscriptionOptions, type WithActiveOrganizationId, type WithStripeCustomerId, stripe };