@lightspeed/online-payments-sdk 1.8.0 → 1.9.1

package/dist/cjs/v1/stripe/widgets/deferredMoto.js

@@ -0,0 +1,203 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountDeferredMotoWidget = mountDeferredMotoWidget;
+var error_1 = require("../../error");
+var ResultBuilder_1 = require("../ResultBuilder");
+var localizedText_1 = require("../localizedText");
+var shared_1 = require("../shared");
+function publishStripeError(error, eventBroadcaster) {
+    return eventBroadcaster.publish(ResultBuilder_1.EventBuilder.fromStripeError(error));
+}
+function mountDeferredMotoWidget(mountElement, session, eventBroadcaster, defaultValues, theme) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, stripe, elements, paymentOptions, _b, paymentElement, paymentContainer, customTermsContainer, finalizationError, savePaymentMethod, revision, unmounted, completedSubmission, clearFinalizationError, invalidateSubmission, hasSaveOption, updateSaveCheckboxState, savePaymentMethodContainer, submission, failSubmission, submit;
+        var _this = this;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, (0, shared_1.initStripe)(session.context, theme)];
+                case 1:
+                    _a = _c.sent(), stripe = _a.stripe, elements = _a.elements;
+                    paymentOptions = (0, shared_1.createPaymentElementOptions)(defaultValues, theme, false, session.context.businessName);
+                    _b = (0, shared_1.createPaymentElement)(elements, paymentOptions, mountElement, eventBroadcaster), paymentElement = _b.element, paymentContainer = _b.container, customTermsContainer = _b.customTermsContainer;
+                    finalizationError = document.createElement('p');
+                    finalizationError.className = 'stripe-finalization-error';
+                    finalizationError.setAttribute('role', 'alert');
+                    finalizationError.hidden = true;
+                    paymentContainer.insertAdjacentElement('afterend', finalizationError);
+                    savePaymentMethod = false;
+                    revision = 0;
+                    unmounted = false;
+                    clearFinalizationError = function () {
+                        finalizationError.hidden = true;
+                        finalizationError.textContent = '';
+                    };
+                    invalidateSubmission = function () {
+                        revision += 1;
+                        completedSubmission = undefined;
+                        clearFinalizationError();
+                    };
+                    hasSaveOption = session.metadata.sessionType === 'moto-with-save';
+                    updateSaveCheckboxState = (0, shared_1.setupChangeEventHandler)(paymentElement, eventBroadcaster, null, invalidateSubmission, hasSaveOption ? false : undefined);
+                    if (hasSaveOption) {
+                        savePaymentMethodContainer = (0, shared_1.createSavePaymentMethodElement)(mountElement, function (checked) {
+                            savePaymentMethod = checked;
+                            invalidateSubmission();
+                            updateSaveCheckboxState(savePaymentMethod);
+                        }, session.context.locale);
+                    }
+                    failSubmission = function (message) {
+                        eventBroadcaster.publish({ status: 'Error', code: 'Processing' });
+                        throw new error_1.ProcessingError(message);
+                    };
+                    submit = function () {
+                        if (unmounted) {
+                            eventBroadcaster.publish({ status: 'Error', code: 'Processing' });
+                            return Promise.reject(new error_1.ProcessingError('The payment widget has been unmounted'));
+                        }
+                        if ((completedSubmission === null || completedSubmission === void 0 ? void 0 : completedSubmission.revision) === revision) {
+                            return Promise.resolve(completedSubmission.result);
+                        }
+                        if (submission) {
+                            if (submission.revision === revision) {
+                                return submission.promise;
+                            }
+                            return submission.promise.then(submit, submit);
+                        }
+                        var submissionRevision = revision;
+                        var submissionSavePaymentMethod = savePaymentMethod;
+                        clearFinalizationError();
+                        var assertSubmissionIsCurrent = function () {
+                            if (unmounted) {
+                                return failSubmission('The payment widget was unmounted during submission');
+                            }
+                            if (revision !== submissionRevision) {
+                                return failSubmission('Payment details or save consent changed during submission');
+                            }
+                        };
+                        var promise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                            var submitResult, paymentMethodResult, result;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0: return [4 /*yield*/, elements.submit()];
+                                    case 1:
+                                        submitResult = _b.sent();
+                                        assertSubmissionIsCurrent();
+                                        if (submitResult.error) {
+                                            return [2 /*return*/, publishStripeError(submitResult.error, eventBroadcaster)];
+                                        }
+                                        return [4 /*yield*/, stripe.createPaymentMethod({ elements: elements })];
+                                    case 2:
+                                        paymentMethodResult = _b.sent();
+                                        assertSubmissionIsCurrent();
+                                        if (paymentMethodResult.error) {
+                                            return [2 /*return*/, publishStripeError(paymentMethodResult.error, eventBroadcaster)];
+                                        }
+                                        if (!((_a = paymentMethodResult.paymentMethod) === null || _a === void 0 ? void 0 : _a.id)) {
+                                            eventBroadcaster.publish({ status: 'Error', code: 'Unexpected' });
+                                            throw new error_1.ProcessingError('Stripe did not return a PaymentMethod ID');
+                                        }
+                                        result = {
+                                            status: 'RequiresFinalization',
+                                            code: 'RequiresFinalization',
+                                            finalizationRequest: {
+                                                paymentData: {
+                                                    type: 'payment-method',
+                                                    id: paymentMethodResult.paymentMethod.id,
+                                                },
+                                                options: {
+                                                    savePaymentMethod: submissionSavePaymentMethod,
+                                                },
+                                            },
+                                        };
+                                        completedSubmission = { revision: submissionRevision, result: result };
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })();
+                        var currentSubmission = { revision: submissionRevision, promise: promise };
+                        submission = currentSubmission;
+                        var clearSubmission = function () {
+                            if (submission === currentSubmission) {
+                                submission = undefined;
+                            }
+                        };
+                        promise.then(clearSubmission, clearSubmission);
+                        return promise;
+                    };
+                    return [2 /*return*/, {
+                            unmount: function () {
+                                if (unmounted) {
+                                    return;
+                                }
+                                unmounted = true;
+                                revision += 1;
+                                completedSubmission = undefined;
+                                (0, shared_1.cleanupElements)(paymentElement, null, paymentContainer, null, customTermsContainer);
+                                finalizationError.remove();
+                                savePaymentMethodContainer === null || savePaymentMethodContainer === void 0 ? void 0 : savePaymentMethodContainer.remove();
+                            },
+                            submit: submit,
+                            reportFinalizationDecline: function (result, message) {
+                                if (unmounted ||
+                                    (completedSubmission === null || completedSubmission === void 0 ? void 0 : completedSubmission.revision) !== revision ||
+                                    completedSubmission.result.finalizationRequest.paymentData.type !==
+                                        result.finalizationRequest.paymentData.type ||
+                                    completedSubmission.result.finalizationRequest.paymentData.id !==
+                                        result.finalizationRequest.paymentData.id ||
+                                    completedSubmission.result.finalizationRequest.options
+                                        .savePaymentMethod !==
+                                        result.finalizationRequest.options.savePaymentMethod) {
+                                    return;
+                                }
+                                invalidateSubmission();
+                                var trimmedMessage = message.trim();
+                                finalizationError.textContent =
+                                    trimmedMessage === 'Payment declined.' || !trimmedMessage
+                                        ? (0, localizedText_1.getCardDeclinedText)(session.context.locale)
+                                        : trimmedMessage;
+                                finalizationError.hidden = false;
+                                paymentElement.focus();
+                                eventBroadcaster.publish({ status: 'Declined', code: 'Generic' });
+                            },
+                        }];
+            }
+        });
+    });
+}

package/dist/cjs/v1/widget.js

@@ -45,9 +45,19 @@ var error_1 = require("./error");
 var logger_1 = require("./logging/logger");
 var common_1 = require("./logging/common");
 var EventBroadcaster_1 = require("./EventBroadcaster");
+var version_1 = require("../version");
+// Exposes the running SDK version on the mount point so it can be inspected
+// in browser devtools (e.g. `document.querySelector('[data-lightspeed-payments-sdk-version]')`).
+var SDK_VERSION_ATTRIBUTE = 'data-lightspeed-payments-sdk-version';
+function markMountPointWithSdkVersion(mountPoint) {
+    mountPoint.setAttribute(SDK_VERSION_ATTRIBUTE, version_1.SDK_VERSION);
+}
+function unmarkMountPointWithSdkVersion(mountPoint) {
+    mountPoint.removeAttribute(SDK_VERSION_ATTRIBUTE);
+}
 function mountPaymentWidget(session, config) {
     return __awaiter(this, void 0, void 0, function () {
-        var eventBroadcaster, decodedSession, logger_2, configSummary, widgetController, _a, error_2;
+        var eventBroadcaster, decodedSession, logger_2, configSummary, widgetController, _a, unmount_1, error_2;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
@@ -86,8 +96,17 @@ function mountPaymentWidget(session, config) {
                     return [3 /*break*/, 7];
                 case 6: throw new error_1.UnsupportedLocationError();
                 case 7:
+                    markMountPointWithSdkVersion(config.mountPoint);
                     widgetController.submit = (0, common_1.withLogging)(logger_2, 'Submit', widgetController.submit);
-                    widgetController.unmount = (0, common_1.withLogging)(logger_2, 'Unmount', widgetController.unmount);
+                    unmount_1 = widgetController.unmount;
+                    widgetController.unmount = (0, common_1.withLogging)(logger_2, 'Unmount', function () {
+                        try {
+                            unmount_1();
+                        }
+                        finally {
+                            unmarkMountPointWithSdkVersion(config.mountPoint);
+                        }
+                    });
                     return [2 /*return*/, widgetController];
                 case 8:
                     error_2 = _b.sent();
@@ -104,7 +123,7 @@ function mountPaymentWidget(session, config) {
 // Internal impl of v1.mountMultiStepWidget (additive; event-based flows unchanged).
 function mountMultiStepWidget(session, config) {
     return __awaiter(this, void 0, void 0, function () {
-        var eventBroadcaster, decodedSession, logger_3, controller, _a, error_3;
+        var eventBroadcaster, decodedSession, logger_3, controller, _a, unmount_2, error_3;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
@@ -137,9 +156,18 @@ function mountMultiStepWidget(session, config) {
                     return [3 /*break*/, 5];
                 case 4: throw new error_1.UnsupportedLocationError();
                 case 5:
+                    markMountPointWithSdkVersion(config.mountPoint);
                     controller.submit = (0, common_1.withLogging)(logger_3, 'Submit', controller.submit);
                     controller.handleNextAction = (0, common_1.withLogging)(logger_3, 'HandleNextAction', controller.handleNextAction);
-                    controller.unmount = (0, common_1.withLogging)(logger_3, 'Unmount', controller.unmount);
+                    unmount_2 = controller.unmount;
+                    controller.unmount = (0, common_1.withLogging)(logger_3, 'Unmount', function () {
+                        try {
+                            unmount_2();
+                        }
+                        finally {
+                            unmarkMountPointWithSdkVersion(config.mountPoint);
+                        }
+                    });
                     return [2 /*return*/, controller];
                 case 6:
                     error_3 = _b.sent();

package/dist/cjs/version.js

@@ -3,4 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
 // This file is auto-generated during the build process
 // DO NOT EDIT MANUALLY - Version is extracted from package.json
-exports.SDK_VERSION = '1.8.0';
+exports.SDK_VERSION = '1.9.1';

package/dist/index.d.ts

@@ -1,5 +1,8 @@
+import { SDK_VERSION } from './version';
 export type * from './v1';
 export { THEME_COLORS } from './v1';
+export { SDK_VERSION };
 export declare const LightspeedPayments: {
     v1: import("./v1").LightspeedPaymentsV1;
+    version: string;
 };

package/dist/index.js

@@ -1,5 +1,8 @@
 import { v1 } from './v1';
+import { SDK_VERSION } from './version';
 export { THEME_COLORS } from './v1';
+export { SDK_VERSION };
 export var LightspeedPayments = {
     v1: v1,
+    version: SDK_VERSION,
 };

package/dist/v1/EventBroadcaster.d.ts

@@ -25,6 +25,23 @@ export type ChangeEvent = BaseEvent & {
     paymentMethodType?: string;
     saveCheckboxChecked?: boolean;
 };
+export type RequiresFinalizationResult = {
+    status: 'RequiresFinalization';
+    code: 'RequiresFinalization';
+    /**
+     * Provider-neutral backend command. Integrations should forward this object
+     * unchanged to their Processing Service finalization endpoint.
+     */
+    finalizationRequest: {
+        paymentData: {
+            type: 'payment-method';
+            id: string;
+        };
+        options: {
+            savePaymentMethod: boolean;
+        };
+    };
+};
 export type ErrorResultEvent = BaseEvent & {
     code: SupportedErrorCodes;
     status: 'Error';
@@ -42,6 +59,6 @@ export declare class EventBroadcaster {
     private convertInternalEventToExternal;
     registerMiddleware(middleware: EventMiddleware): void;
     applyMiddlewares(event: InternalEvent): Event;
-    publish(event: InternalEvent): void;
+    publish(event: InternalEvent): Event;
 }
 export {};

package/dist/v1/EventBroadcaster.js

@@ -63,6 +63,7 @@ var EventBroadcaster = /** @class */ (function () {
         var processedEvent = this.applyMiddlewares(event);
         var eventListener = this.listenersRegistry[event.status];
         eventListener(processedEvent);
+        return processedEvent;
     };
     return EventBroadcaster;
 }());

package/dist/v1/adyen/widget.js

@@ -83,7 +83,7 @@ function mountSessionsFlow(mountElement, context, eventBroadcaster) {
 }
 // Multi-step Advanced flow: submit() surfaces the encrypted payment data for
 // the host to POST; handleNextAction() feeds the server response back to drive
-// native 3DS2. See MultiStepController in common.ts.
+// 3DS actions. See MultiStepController in common.ts.
 function mountAdvancedFlow(mountElement, context, eventBroadcaster, onRequiresFinalization) {
     return __awaiter(this, void 0, void 0, function () {
         var stashedActions, pendingResolve, isValid, checkoutConfig, checkout, dropinConfiguration, dropIn;
@@ -164,7 +164,7 @@ function mountAdvancedFlow(mountElement, context, eventBroadcaster, onRequiresFi
                 case 1:
                     checkout = _b.sent();
                     dropinConfiguration = {
-                        paymentMethodComponents: [Card, ApplePay, GooglePay, Bancontact],
+                        paymentMethodComponents: [Card, ApplePay, GooglePay, Bancontact, Redirect],
                         showStoredPaymentMethods: false,
                         paymentMethodsConfiguration: {
                             card: {
@@ -206,17 +206,8 @@ function mountAdvancedFlow(mountElement, context, eventBroadcaster, onRequiresFi
                                     var _a;
                                     var response = (serverResponse !== null && serverResponse !== void 0 ? serverResponse : {});
                                     if (response.action) {
-                                        // 3DS1 (redirect) is out of scope: surface as an error so the host can
-                                        // ask the shopper for a different card.
-                                        if (response.action.type === 'redirect') {
-                                            resolve({
-                                                status: 'Error',
-                                                error: { code: 'RedirectNotSupported', resultCode: response.resultCode },
-                                            });
-                                            return;
-                                        }
-                                        // Native 3DS2 step: let the component perform it, then resolve once
-                                        // onAdditionalDetails hands us the next payload for the host to POST.
+                                        // Let Adyen Web perform the action. Native challenges call
+                                        // onAdditionalDetails; redirect actions navigate away to the issuer.
                                         pendingResolve = resolve;
                                         stashedActions === null || stashedActions === void 0 ? void 0 : stashedActions.resolve(response);
                                         return;

package/dist/v1/common.d.ts

@@ -1,10 +1,16 @@
-import { EventBroadcaster, Event } from './EventBroadcaster';
+import { EventBroadcaster, Event, RequiresFinalizationResult } from './EventBroadcaster';
 import { Session } from './session';
 import { PaymentWidgetTheme } from './widget';
 export type SessionType = 'payment' | 'payment-with-save' | 'moto' | 'moto-with-save' | 'save';
+export type WidgetSubmitResult = Event | RequiresFinalizationResult;
 export type WidgetController = {
     unmount: () => void;
-    submit: () => Promise<Event>;
+    submit: () => Promise<WidgetSubmitResult>;
+    /**
+     * Deferred MOTO only. Reports a definitive backend decline so the widget can
+     * present it and collect a fresh PaymentMethod on the next submission.
+     */
+    reportFinalizationDecline?: (result: RequiresFinalizationResult, message: string) => void;
 };
 export type MultiStepResult = {
     status: 'RequiresFinalization';

package/dist/v1/index.d.ts

@@ -6,8 +6,8 @@
  */
 import { WidgetController, MultiStepController } from './common';
 import { PaymentWidgetConfiguration } from './widget';
-export type { WidgetController, MultiStepController, MultiStepResult, SessionType, DefaultValues, } from './common';
-export type { Event } from './EventBroadcaster';
+export type { WidgetController, MultiStepController, MultiStepResult, SessionType, DefaultValues, WidgetSubmitResult, } from './common';
+export type { Event, RequiresFinalizationResult } from './EventBroadcaster';
 export { UnsupportedLocationError, InvalidSessionPayloadError, InvalidSessionError, ProcessingError, } from './error';
 export type { PaymentWidgetConfiguration, PaymentWidgetTheme } from './widget';
 export { THEME_COLORS } from './stripe/themes';

package/dist/v1/stripe/localizedText.d.ts

@@ -0,0 +1,3 @@
+/** Locale-selected UI text rendered alongside Stripe Elements. */
+export declare function getSavePaymentMethodText(locale?: string): string;
+export declare function getCardDeclinedText(locale?: string): string;

package/dist/v1/stripe/localizedText.js

@@ -0,0 +1,28 @@
+/** Locale-selected UI text rendered alongside Stripe Elements. */
+var SAVE_PAYMENT_METHOD_TEXT = {
+    de: 'Zahlungsinformationen für zukünftige Einkäufe speichern',
+    en: 'Save payment details for future purchases',
+    fr: 'Enregistrer les informations de paiement pour vos prochains achats',
+    nl: 'Betaalgegevens opslaan voor toekomstige aankopen',
+};
+var CARD_DECLINED_TEXT = {
+    de: 'Ihre Karte wurde abgelehnt.',
+    en: 'Your card was declined.',
+    fr: 'Votre carte a été refusée.',
+    nl: 'Uw kaart is geweigerd.',
+};
+function getLanguage(locale) {
+    var _a;
+    var resolvedLocale = !locale || locale === 'auto'
+        ? ((_a = globalThis.navigator) === null || _a === void 0 ? void 0 : _a.language) || 'en'
+        : locale;
+    return resolvedLocale.toLowerCase().split('-')[0];
+}
+export function getSavePaymentMethodText(locale) {
+    var language = getLanguage(locale);
+    return SAVE_PAYMENT_METHOD_TEXT[language] || SAVE_PAYMENT_METHOD_TEXT.en;
+}
+export function getCardDeclinedText(locale) {
+    var language = getLanguage(locale);
+    return CARD_DECLINED_TEXT[language] || CARD_DECLINED_TEXT.en;
+}

package/dist/v1/stripe/session.d.ts

@@ -1,15 +1,38 @@
 import { StripeElementLocale } from '@stripe/stripe-js';
 import { BaseSession } from '../session';
-export type StripeSession = BaseSession & {
+export type StripeBaseSession = BaseSession & {
     psp: 'STRIPE';
-    context: StripeContext;
 };
-export type StripeContext = {
-    clientSecret: string;
+type StripeContextBase = {
     publishableKey: string;
+    locale?: StripeElementLocale;
+    businessName?: string;
+};
+export type IntentBoundStripeContext = StripeContextBase & {
+    intentMode?: 'intent-bound';
+    clientSecret: string;
     customerSessionClientSecret?: string;
     intent: 'save-card' | 'payment';
-    locale?: StripeElementLocale;
     redirectUrl?: string;
-    businessName?: string;
 };
+export type DeferredStripeContext = StripeContextBase & {
+    intentMode: 'deferred';
+    intent: 'payment';
+    amount: number;
+    currency: string;
+    paymentMethodTypes: string[];
+    onBehalfOf: string;
+    clientSecret?: never;
+    customerSessionClientSecret?: never;
+};
+export type StripeContext = IntentBoundStripeContext | DeferredStripeContext;
+export type IntentBoundStripeSession = StripeBaseSession & {
+    context: IntentBoundStripeContext;
+};
+export type DeferredStripeSession = StripeBaseSession & {
+    context: DeferredStripeContext;
+};
+export type StripeSession = IntentBoundStripeSession | DeferredStripeSession;
+export declare function isDeferredStripeSession(session: StripeSession): session is DeferredStripeSession;
+export declare function isIntentBoundStripeSession(session: StripeSession): session is IntentBoundStripeSession;
+export {};

package/dist/v1/stripe/session.js

@@ -1 +1,7 @@
-export {};
+export function isDeferredStripeSession(session) {
+    return session.context.intentMode === 'deferred';
+}
+export function isIntentBoundStripeSession(session) {
+    return (session.context.intentMode === undefined ||
+        session.context.intentMode === 'intent-bound');
+}

package/dist/v1/stripe/shared.d.ts

@@ -1,6 +1,6 @@
 import { StripePaymentElementOptions, StripeAddressElementOptions } from '@stripe/stripe-js';
 import type { StripeElements, Stripe, StripeAddressElement, StripePaymentElement } from '@stripe/stripe-js';
-import { StripeContext, StripeSession } from './session';
+import { IntentBoundStripeSession, StripeContext } from './session';
 import { DefaultValues } from '../common';
 import { EventBroadcaster } from '../EventBroadcaster';
 import { PaymentWidgetTheme } from '../widget';
@@ -45,6 +45,7 @@ export declare function buildCardConsentText(businessName: string, reason: strin
  * text.
  */
 export declare function createCardConsentElement(consentText: string): HTMLElement;
+export declare function createSavePaymentMethodElement(mountElement: HTMLElement, onChange: (checked: boolean) => void, locale?: string): HTMLElement;
 /**
  * Create and mount payment element
  */
@@ -61,7 +62,9 @@ export declare function createPaymentElement(elements: StripeElements, options:
  * Also includes the current save-payment-method checkbox state (when present) on every Change event,
  * and emits a Change event when that checkbox state changes.
  */
-export declare function setupChangeEventHandler(paymentElement: StripePaymentElement, eventBroadcaster: EventBroadcaster, addressElement?: StripeAddressElement | null): void;
+export declare function setupChangeEventHandler(paymentElement: StripePaymentElement, eventBroadcaster: EventBroadcaster, addressElement?: StripeAddressElement | null, onPaymentValueChange?: (value: {
+    savePaymentMethod?: boolean;
+}) => void, initialSaveCheckboxState?: boolean): (saveCheckboxChecked: boolean) => void;
 /**
  * Create and mount address element
  */
@@ -76,12 +79,12 @@ export declare function cleanupElements(paymentElement: StripePaymentElement, ad
 /**
  * Handle save card operation
  */
-export declare function handleSaveCard(stripe: Stripe, elements: StripeElements, session: StripeSession, addressElement?: StripeAddressElement | null): Promise<import("../EventBroadcaster").SucceededResultEvent | import("../EventBroadcaster").PendingResultEvent | import("../EventBroadcaster").DeclinedResultEvent | import("../EventBroadcaster").ErrorResultEvent>;
+export declare function handleSaveCard(stripe: Stripe, elements: StripeElements, session: IntentBoundStripeSession, addressElement?: StripeAddressElement | null): Promise<import("../EventBroadcaster").SucceededResultEvent | import("../EventBroadcaster").PendingResultEvent | import("../EventBroadcaster").DeclinedResultEvent | import("../EventBroadcaster").ErrorResultEvent>;
 /**
  * Handle payment operation
  */
-export declare function handlePayment(stripe: Stripe, elements: StripeElements, session: StripeSession, addressElement?: StripeAddressElement | null): Promise<import("../EventBroadcaster").SucceededResultEvent | import("../EventBroadcaster").PendingResultEvent | import("../EventBroadcaster").DeclinedResultEvent | import("../EventBroadcaster").ErrorResultEvent>;
+export declare function handlePayment(stripe: Stripe, elements: StripeElements, session: IntentBoundStripeSession, addressElement?: StripeAddressElement | null): Promise<import("../EventBroadcaster").SucceededResultEvent | import("../EventBroadcaster").PendingResultEvent | import("../EventBroadcaster").DeclinedResultEvent | import("../EventBroadcaster").ErrorResultEvent>;
 /**
  * Create common submit handler for widgets
  */
-export declare function createSubmitHandler(stripe: Stripe, elements: StripeElements, session: StripeSession, eventBroadcaster: EventBroadcaster, addressElement?: StripeAddressElement | null): () => Promise<import("../EventBroadcaster").SucceededResultEvent | import("../EventBroadcaster").PendingResultEvent | import("../EventBroadcaster").DeclinedResultEvent | import("../EventBroadcaster").ErrorResultEvent>;
+export declare function createSubmitHandler(stripe: Stripe, elements: StripeElements, session: IntentBoundStripeSession, eventBroadcaster: EventBroadcaster, addressElement?: StripeAddressElement | null): () => Promise<import("../EventBroadcaster").SucceededResultEvent | import("../EventBroadcaster").PendingResultEvent | import("../EventBroadcaster").DeclinedResultEvent | import("../EventBroadcaster").ErrorResultEvent>;