@funnelsgrove/payments 0.1.0 → 0.1.2

package/dist/services/paywallOffer.service.js

@@ -0,0 +1,312 @@
+const isBillingDiscountList = (discounts) => {
+    return Array.isArray(discounts);
+};
+export const buildBillingDiscountCatalog = (discounts) => {
+    if (!isBillingDiscountList(discounts)) {
+        return discounts;
+    }
+    const first = discounts.find((discount) => discount.stage === 'first');
+    const second = discounts.find((discount) => discount.stage === 'second');
+    if (!first || !second) {
+        throw new Error('Billing discounts must include first and second stages');
+    }
+    return {
+        first,
+        second,
+    };
+};
+const PROMO_MONTHS = [
+    'jan',
+    'feb',
+    'mar',
+    'apr',
+    'may',
+    'jun',
+    'jul',
+    'aug',
+    'sep',
+    'oct',
+    'nov',
+    'dec',
+];
+const BILLING_INTERVAL_DAYS = {
+    day: 1,
+    week: 7,
+    month: 30,
+    year: 365,
+};
+const clampRemainingSeconds = (value) => {
+    if (!Number.isFinite(value) || value <= 0) {
+        return 0;
+    }
+    return Math.max(0, Math.ceil(value));
+};
+const parseStoredSnapshot = (storedValue) => {
+    if (!storedValue) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(storedValue);
+        return typeof parsed === 'object' && parsed ? parsed : null;
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const parseStoredTimestamp = (value) => {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+};
+const getDiscount = (discounts, stage) => {
+    return discounts[stage];
+};
+const getDiscountDurationMs = (discounts, stage) => {
+    return getDiscount(discounts, stage).durationSeconds * 1000;
+};
+const getActiveStage = (stage) => {
+    return stage === 'second' || stage === 'upgraded' || stage === 'completed'
+        ? 'second'
+        : 'first';
+};
+const getStoredStage = (snapshot) => {
+    if (snapshot.stage) {
+        return snapshot.stage;
+    }
+    if (snapshot.offerStage === 'upgraded') {
+        return 'second';
+    }
+    if (snapshot.offerStage === 'completed') {
+        return 'completed';
+    }
+    return 'first';
+};
+const getExpiredStartedAtMs = (discounts, nowMs, stage) => {
+    return nowMs - getDiscountDurationMs(discounts, stage) - 1;
+};
+const getStoredDiscountStarts = (discounts, snapshot, nowMs) => {
+    var _a, _b;
+    const firstStartedAtMs = (_a = parseStoredTimestamp(snapshot.firstStartedAt)) !== null && _a !== void 0 ? _a : parseStoredTimestamp(snapshot.discountStartedAt);
+    const secondStartedAtMs = (_b = parseStoredTimestamp(snapshot.secondStartedAt)) !== null && _b !== void 0 ? _b : parseStoredTimestamp(snapshot.additionalDiscountStartedAt);
+    if (firstStartedAtMs !== null || secondStartedAtMs !== null) {
+        return {
+            firstStartedAtMs,
+            secondStartedAtMs,
+        };
+    }
+    const stage = getStoredStage(snapshot);
+    if (typeof snapshot.expiresAtMs === 'number') {
+        const activeStage = getActiveStage(stage);
+        const startedAtMs = snapshot.expiresAtMs - getDiscountDurationMs(discounts, activeStage);
+        return activeStage === 'second'
+            ? {
+                firstStartedAtMs: null,
+                secondStartedAtMs: startedAtMs,
+            }
+            : {
+                firstStartedAtMs: startedAtMs,
+                secondStartedAtMs: null,
+            };
+    }
+    if (snapshot.status === 'expired') {
+        const activeStage = getActiveStage(stage);
+        const expiredStartedAtMs = getExpiredStartedAtMs(discounts, nowMs, activeStage);
+        return activeStage === 'second'
+            ? {
+                firstStartedAtMs: null,
+                secondStartedAtMs: expiredStartedAtMs,
+            }
+            : {
+                firstStartedAtMs: expiredStartedAtMs,
+                secondStartedAtMs: null,
+            };
+    }
+    return null;
+};
+const createExpiredDiscountState = (input = {}) => {
+    var _a, _b, _c;
+    return {
+        status: 'expired',
+        stage: (_a = input.stage) !== null && _a !== void 0 ? _a : 'completed',
+        couponId: null,
+        discountPercent: null,
+        previousDiscountPercent: null,
+        expiresAtMs: null,
+        remainingSeconds: 0,
+        firstStartedAtMs: (_b = input.firstStartedAtMs) !== null && _b !== void 0 ? _b : null,
+        secondStartedAtMs: (_c = input.secondStartedAtMs) !== null && _c !== void 0 ? _c : null,
+    };
+};
+const createDiscountStateFromStarts = (input) => {
+    var _a, _b;
+    if (typeof input.secondStartedAtMs === 'number') {
+        const activeDiscount = getDiscount(input.discounts, 'second');
+        const expiresAtMs = input.secondStartedAtMs + getDiscountDurationMs(input.discounts, 'second');
+        const remainingSeconds = clampRemainingSeconds((expiresAtMs - input.nowMs) / 1000);
+        if (remainingSeconds <= 0) {
+            return createExpiredDiscountState({
+                stage: 'completed',
+                firstStartedAtMs: input.firstStartedAtMs,
+                secondStartedAtMs: input.secondStartedAtMs,
+            });
+        }
+        return {
+            status: 'active',
+            stage: 'second',
+            couponId: activeDiscount.couponId,
+            discountPercent: activeDiscount.discountPercent,
+            previousDiscountPercent: (_a = activeDiscount.previousDiscountPercent) !== null && _a !== void 0 ? _a : null,
+            expiresAtMs,
+            remainingSeconds,
+            firstStartedAtMs: input.firstStartedAtMs,
+            secondStartedAtMs: input.secondStartedAtMs,
+        };
+    }
+    if (typeof input.firstStartedAtMs !== 'number') {
+        return createDiscountStateFromStarts(Object.assign(Object.assign({}, input), { firstStartedAtMs: input.nowMs, secondStartedAtMs: null }));
+    }
+    const activeDiscount = getDiscount(input.discounts, 'first');
+    const expiresAtMs = input.firstStartedAtMs + getDiscountDurationMs(input.discounts, 'first');
+    const remainingSeconds = clampRemainingSeconds((expiresAtMs - input.nowMs) / 1000);
+    if (remainingSeconds <= 0) {
+        return createExpiredDiscountState({
+            stage: 'first',
+            firstStartedAtMs: input.firstStartedAtMs,
+            secondStartedAtMs: input.secondStartedAtMs,
+        });
+    }
+    return {
+        status: 'active',
+        stage: 'first',
+        couponId: activeDiscount.couponId,
+        discountPercent: activeDiscount.discountPercent,
+        previousDiscountPercent: (_b = activeDiscount.previousDiscountPercent) !== null && _b !== void 0 ? _b : null,
+        expiresAtMs,
+        remainingSeconds,
+        firstStartedAtMs: input.firstStartedAtMs,
+        secondStartedAtMs: input.secondStartedAtMs,
+    };
+};
+export const resolvePaywallDiscountState = (input) => {
+    const snapshot = parseStoredSnapshot(input.storedValue);
+    if (!snapshot) {
+        return createDiscountStateFromStarts({
+            discounts: input.discounts,
+            nowMs: input.nowMs,
+            firstStartedAtMs: input.nowMs,
+            secondStartedAtMs: null,
+        });
+    }
+    const storedStarts = getStoredDiscountStarts(input.discounts, snapshot, input.nowMs);
+    if (!storedStarts) {
+        return createDiscountStateFromStarts({
+            discounts: input.discounts,
+            nowMs: input.nowMs,
+            firstStartedAtMs: input.nowMs,
+            secondStartedAtMs: null,
+        });
+    }
+    return createDiscountStateFromStarts({
+        discounts: input.discounts,
+        nowMs: input.nowMs,
+        firstStartedAtMs: storedStarts.firstStartedAtMs,
+        secondStartedAtMs: storedStarts.secondStartedAtMs,
+    });
+};
+export const serializePaywallDiscountState = (state) => {
+    return JSON.stringify({
+        firstStartedAt: state.firstStartedAtMs,
+        secondStartedAt: state.secondStartedAtMs,
+    });
+};
+export const advancePaywallDiscountState = (input) => {
+    return createDiscountStateFromStarts({
+        discounts: input.discounts,
+        nowMs: input.nowMs,
+        firstStartedAtMs: input.state.firstStartedAtMs,
+        secondStartedAtMs: input.state.secondStartedAtMs,
+    });
+};
+export const activateSecondPaywallDiscount = (input) => {
+    var _a;
+    if (typeof input.state.secondStartedAtMs === 'number' ||
+        input.state.stage === 'completed') {
+        return input.state;
+    }
+    return createDiscountStateFromStarts({
+        discounts: input.discounts,
+        nowMs: input.nowMs,
+        firstStartedAtMs: (_a = input.state.firstStartedAtMs) !== null && _a !== void 0 ? _a : input.nowMs,
+        secondStartedAtMs: input.nowMs,
+    });
+};
+export const getDiscountedAmountCents = (amountCents, discountPercent) => {
+    const normalizedAmount = Number.isFinite(amountCents)
+        ? Math.max(0, Math.round(amountCents))
+        : 0;
+    const normalizedDiscountPercent = Math.min(100, Math.max(0, Math.round(discountPercent)));
+    return Math.max(0, Math.round((normalizedAmount * (100 - normalizedDiscountPercent)) / 100));
+};
+const formatMoneyFromCents = (amountCents, currency, locale) => {
+    return new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency,
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    }).format(amountCents / 100);
+};
+const getBillingDays = (plan) => {
+    const interval = plan.billingInterval;
+    if (!interval) {
+        return null;
+    }
+    const intervalCount = plan.billingIntervalCount && plan.billingIntervalCount > 0
+        ? plan.billingIntervalCount
+        : 1;
+    return BILLING_INTERVAL_DAYS[interval] * intervalCount;
+};
+export const buildDiscountedPaywallPlans = (input) => {
+    var _a, _b;
+    const currency = ((_a = input.currency) === null || _a === void 0 ? void 0 : _a.trim()) || 'USD';
+    const locale = ((_b = input.locale) === null || _b === void 0 ? void 0 : _b.trim()) || 'en-US';
+    return input.plans.map((plan) => {
+        var _a;
+        const billingDays = getBillingDays(plan);
+        const hasActiveDiscount = Boolean(input.couponId) && typeof input.discountPercent === 'number';
+        const discountedAmountCents = hasActiveDiscount
+            ? getDiscountedAmountCents(plan.amountCents, (_a = input.discountPercent) !== null && _a !== void 0 ? _a : 0)
+            : plan.amountCents;
+        const discountedPerDayAmount = billingDays && billingDays > 0
+            ? formatMoneyFromCents(Math.round(discountedAmountCents / billingDays), currency, locale)
+            : plan.perDayAmount;
+        return Object.assign(Object.assign({}, plan), { amountCents: discountedAmountCents, priceLabel: hasActiveDiscount
+                ? formatMoneyFromCents(discountedAmountCents, currency, locale)
+                : plan.priceLabel, oldPriceLabel: hasActiveDiscount ? plan.priceLabel : undefined, perDayAmount: hasActiveDiscount ? discountedPerDayAmount : plan.perDayAmount, baseAmountCents: plan.amountCents, basePriceLabel: plan.priceLabel, basePerDayAmount: plan.perDayAmount, oldPerDayAmount: hasActiveDiscount ? plan.perDayAmount : null, couponId: hasActiveDiscount ? input.couponId : null, hasActiveDiscount });
+    });
+};
+export const getPaywallPromoDisplayName = (referenceMs) => {
+    var _a;
+    const referenceDate = new Date(referenceMs);
+    if (Number.isNaN(referenceDate.getTime())) {
+        return 'discount_offer';
+    }
+    const monthLabel = (_a = PROMO_MONTHS[referenceDate.getMonth()]) !== null && _a !== void 0 ? _a : 'discount';
+    return `${monthLabel}_${referenceDate.getFullYear()}`;
+};
+const formatRecurringCadence = (plan) => {
+    const interval = plan.billingInterval;
+    if (!interval) {
+        return 'on your selected billing schedule';
+    }
+    const count = plan.billingIntervalCount && plan.billingIntervalCount > 0
+        ? plan.billingIntervalCount
+        : 1;
+    if (count === 1) {
+        return `every ${interval}`;
+    }
+    return `every ${count} ${interval}s`;
+};
+export const buildPaywallRenewalDisclaimer = (input) => {
+    var _a;
+    const introLabel = input.hasActiveDiscount ? 'discounted intro plan' : 'selected plan';
+    const productPrefix = ((_a = input.productName) === null || _a === void 0 ? void 0 : _a.trim()) ? `${input.productName.trim()} ` : '';
+    return `Without cancellation, before the selected ${introLabel} ends, I accept that ${productPrefix}will automatically charge ${input.plan.priceLabel} ${formatRecurringCadence(input.plan)} until I cancel. Cancel online via the profile on the website or app.`;
+};

package/dist/services/planCatalog.service.d.ts

@@ -0,0 +1,28 @@
+import type { BillingFallbackPlanConfig, BillingPlanCatalog, BillingPlanMappingCatalog } from '../config/billing.config.js';
+export type RemoteProjectBillingPlan = {
+    id: string;
+    key: string;
+    projectPlanId: string | null;
+    providerPlanId: string;
+    displayName: string | null;
+    description: string | null;
+    interval: string | null;
+    intervalCount: number | null;
+    trialPeriodDays: number | null;
+    currency: string | null;
+    amountMinor: number | null;
+    amountDecimal: string | null;
+    metadata: Record<string, unknown>;
+    isActive: boolean;
+};
+export type ResolvedMappedProjectBillingPlan = RemoteProjectBillingPlan & {
+    funnelKey: string;
+};
+export type BillingPlanListItem = BillingFallbackPlanConfig & {
+    key: string;
+};
+export declare const isBillingPlanMappingCatalog: (value: unknown) => value is BillingPlanMappingCatalog;
+export declare const buildBillingPlanMappingCatalog: (planCatalog: BillingPlanCatalog) => BillingPlanMappingCatalog;
+export declare const buildBillingPlanList: (planCatalog: BillingPlanCatalog) => BillingPlanListItem[];
+export declare const getFallbackBillingPlans: (planCatalog?: BillingPlanCatalog | readonly BillingFallbackPlanConfig[]) => BillingFallbackPlanConfig[];
+export declare const resolveMappedProjectPlans: (mappingCatalog: BillingPlanMappingCatalog, projectPlans: readonly RemoteProjectBillingPlan[]) => ResolvedMappedProjectBillingPlan[];

package/dist/services/planCatalog.service.js

@@ -0,0 +1,60 @@
+const isRecord = (value) => {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+};
+const isBillingPlanMappingConfig = (value) => {
+    if (!isRecord(value) || typeof value.projectPlanId !== 'string') {
+        return false;
+    }
+    return Object.keys(value).every((key) => key === 'projectPlanId');
+};
+export const isBillingPlanMappingCatalog = (value) => {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const entries = Object.values(value);
+    return entries.length > 0 && entries.every((entry) => isBillingPlanMappingConfig(entry));
+};
+export const buildBillingPlanMappingCatalog = (planCatalog) => {
+    return Object.fromEntries(Object.entries(planCatalog).flatMap(([key, plan]) => {
+        const planKey = key.trim();
+        const projectPlanId = plan.projectPlanId.trim();
+        if (!planKey || !projectPlanId) {
+            return [];
+        }
+        return [
+            [
+                planKey,
+                {
+                    projectPlanId,
+                },
+            ],
+        ];
+    }));
+};
+export const buildBillingPlanList = (planCatalog) => {
+    return Object.entries(planCatalog).map(([key, plan]) => (Object.assign({ key }, plan)));
+};
+export const getFallbackBillingPlans = (planCatalog) => {
+    if (!planCatalog) {
+        return [];
+    }
+    if (Array.isArray(planCatalog)) {
+        return [...planCatalog];
+    }
+    return Object.values(planCatalog);
+};
+export const resolveMappedProjectPlans = (mappingCatalog, projectPlans) => {
+    const projectPlanById = new Map(projectPlans.flatMap((plan) => {
+        const keys = [plan.projectPlanId, plan.id].filter((key) => typeof key === 'string' && key.length > 0);
+        return keys.map((key) => [key, plan]);
+    }));
+    return Object.entries(mappingCatalog).flatMap(([funnelKey, mapping]) => {
+        const projectPlan = projectPlanById.get(mapping.projectPlanId) || null;
+        if (!projectPlan) {
+            return [];
+        }
+        return [
+            Object.assign(Object.assign({}, projectPlan), { funnelKey }),
+        ];
+    });
+};

package/dist/services/runtimeBillingPlanCatalog.service.d.ts

@@ -0,0 +1,6 @@
+import type { BillingPlanCatalog } from '../config/billing.config.js';
+export type RuntimeModeBillingPlanCatalog = {
+    test?: BillingPlanCatalog;
+    live?: BillingPlanCatalog;
+};
+export declare const createRuntimeModeBillingPlanCatalog: (catalogsByMode: RuntimeModeBillingPlanCatalog) => BillingPlanCatalog;

package/dist/services/runtimeBillingPlanCatalog.service.js

@@ -0,0 +1,24 @@
+import { getRuntimeMode } from '@funnelsgrove/runtime';
+const EMPTY_BILLING_PLAN_CATALOG = {};
+const resolveBillingPlanCatalog = (catalogsByMode) => {
+    const preferredMode = getRuntimeMode() === 'test' ? 'test' : 'live';
+    const fallbackMode = preferredMode === 'test' ? 'live' : 'test';
+    return catalogsByMode[preferredMode] || catalogsByMode[fallbackMode] || EMPTY_BILLING_PLAN_CATALOG;
+};
+export const createRuntimeModeBillingPlanCatalog = (catalogsByMode) => {
+    return new Proxy({}, {
+        get(_target, property) {
+            return Reflect.get(resolveBillingPlanCatalog(catalogsByMode), property);
+        },
+        getOwnPropertyDescriptor(_target, property) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(resolveBillingPlanCatalog(catalogsByMode), property);
+            return descriptor ? Object.assign(Object.assign({}, descriptor), { configurable: true }) : undefined;
+        },
+        has(_target, property) {
+            return Reflect.has(resolveBillingPlanCatalog(catalogsByMode), property);
+        },
+        ownKeys() {
+            return Reflect.ownKeys(resolveBillingPlanCatalog(catalogsByMode));
+        },
+    });
+};

package/dist/services/stripe.service.d.ts

@@ -1,6 +1,8 @@
 import { type Stripe } from '@stripe/stripe-js';
-import { type BillingFallbackPlanConfig, type BillingPlanCatalog } from '../config/billing.config';
+import { type BillingFallbackPlanConfig, type BillingPlanCatalog, type BillingPlanInterval, type BillingPlanInputCatalog } from '../config/billing.config.js';
+import { type ResolvedCountryPricing } from '@funnelsgrove/runtime';
 import type { RuntimeMode } from '@funnelsgrove/runtime';
+import { type RemoteProjectBillingPlan } from './planCatalog.service.js';
 export type PaywallPlan = {
     id: string;
     title: string;
@@ -15,19 +17,46 @@ export type PaywallPlan = {
     comparison?: BillingFallbackPlanConfig['comparison'];
     checkoutOriginalAmountCents?: number;
     checkoutSummaryLabel?: string;
+    billingInterval?: BillingPlanInterval;
+    billingIntervalCount?: number;
     source: 'stripe' | 'config';
 };
-export declare function getFallbackPlans(planCatalog?: BillingPlanCatalog | readonly BillingFallbackPlanConfig[]): readonly PaywallPlan[];
-export declare function getDefaultPlanId(plans: readonly PaywallPlan[]): string | null;
-export declare function getStripeSyncedPlans(mode: RuntimeMode): Promise<readonly PaywallPlan[]>;
-export declare function getPaywallPlans(mode: RuntimeMode, planCatalog?: BillingPlanCatalog | readonly BillingFallbackPlanConfig[]): Promise<readonly PaywallPlan[]>;
+export type StripeRuntimeConfigOverrides = {
+    apiBaseUrl?: string | null;
+    funnelId?: string | null;
+    funnelVersionId?: string | null;
+    funnelSdkPublishableKey?: string | null;
+};
+export type PaywallPlanResolutionOptions = {
+    locale?: string | null;
+    pricing?: ResolvedCountryPricing<string> | null;
+};
+export declare const buildPaywallPlanResolutionSignature: (options?: PaywallPlanResolutionOptions) => string;
+export declare function buildConfigPaywallPlans(planCatalog?: BillingPlanCatalog | readonly BillingFallbackPlanConfig[], orderedPlanIds?: readonly string[]): readonly PaywallPlan[];
+export declare function getFallbackPlans(planCatalog?: BillingPlanInputCatalog | readonly BillingFallbackPlanConfig[], options?: PaywallPlanResolutionOptions): readonly PaywallPlan[];
+export declare function getOrderedPaywallPlans(plans: readonly PaywallPlan[], orderedPlanIds: readonly string[]): readonly PaywallPlan[];
+export declare function getDefaultPlanId(plans: readonly PaywallPlan[], pricing?: ResolvedCountryPricing<string> | null): string | null;
+export declare function getPaywallPlanSelectionValue(plan: Pick<PaywallPlan, 'id' | 'providerPlanId'>): string;
+export declare function findPaywallPlan(plans: readonly PaywallPlan[], selectionValue: string | null | undefined): PaywallPlan | null;
+export declare function getDefaultPlanSelectionValue(plans: readonly PaywallPlan[], pricing?: ResolvedCountryPricing<string> | null): string | null;
+export declare function getStripeSyncedPlans(mode: RuntimeMode, planCatalog?: BillingPlanInputCatalog | readonly BillingFallbackPlanConfig[], options?: PaywallPlanResolutionOptions): Promise<readonly PaywallPlan[]>;
+export declare function resolvePaywallPlansFromProjectPlans(projectPlans: readonly RemoteProjectBillingPlan[], planCatalog?: BillingPlanInputCatalog | readonly BillingFallbackPlanConfig[], options?: PaywallPlanResolutionOptions): readonly PaywallPlan[];
+export declare function getPaywallPlans(mode: RuntimeMode, planCatalog?: BillingPlanInputCatalog | readonly BillingFallbackPlanConfig[], options?: PaywallPlanResolutionOptions): Promise<readonly PaywallPlan[]>;
 export declare function isStripeConfigured(mode: RuntimeMode): boolean;
 export declare function getStripePromise(mode: RuntimeMode, runtimePublishableKey?: string | null): Promise<Stripe | null> | null;
+type CheckoutSessionPlanInput = Pick<PaywallPlan, 'amountCents' | 'billingInterval' | 'billingIntervalCount' | 'description' | 'id' | 'providerPlanId' | 'title'>;
+type CheckoutPlanRecurringConfig = {
+    interval: BillingPlanInterval;
+    intervalCount: number;
+};
+export declare const resolveCheckoutPlanRecurringConfig: (plan: CheckoutSessionPlanInput) => CheckoutPlanRecurringConfig | null;
 type CreatePaymentIntentInput = {
     planId: string;
     amountCents: number;
-    externalUserId?: string | null;
+    couponId?: string | null;
+    user_id?: string | null;
     environment?: RuntimeMode;
+    runtimeConfig?: StripeRuntimeConfigOverrides;
 };
 type CreatePaymentIntentResponse = {
     clientSecret: string;
@@ -35,4 +64,35 @@ type CreatePaymentIntentResponse = {
     environment?: 'test' | 'live';
 };
 export declare function createStripePaymentIntent(input: CreatePaymentIntentInput): Promise<CreatePaymentIntentResponse>;
+type CreateSubscriptionCheckoutInput = {
+    plan: CheckoutSessionPlanInput;
+    couponId?: string | null;
+    customerEmail?: string | null;
+    user_id?: string | null;
+    environment?: RuntimeMode;
+    runtimeConfig?: StripeRuntimeConfigOverrides;
+};
+type CreateSubscriptionCheckoutResponse = {
+    clientSecret: string;
+    subscriptionId?: string;
+    stripePublishableKey?: string;
+    environment?: 'test' | 'live';
+};
+export declare function createStripeSubscriptionCheckout(input: CreateSubscriptionCheckoutInput): Promise<CreateSubscriptionCheckoutResponse>;
+type CreateCheckoutSessionInput = {
+    plan: CheckoutSessionPlanInput;
+    successUrl: string;
+    cancelUrl: string;
+    couponId?: string | null;
+    customerEmail?: string | null;
+    user_id?: string | null;
+    environment?: RuntimeMode;
+    runtimeConfig?: StripeRuntimeConfigOverrides;
+};
+type CreateCheckoutSessionResponse = {
+    sessionId?: string;
+    url: string;
+};
+export declare function createStripeCheckoutSession(input: CreateCheckoutSessionInput): Promise<CreateCheckoutSessionResponse>;
+export declare function redirectToStripeCheckout(input: CreateCheckoutSessionInput): Promise<string>;
 export {};