@economist/web-apple-pay 1.5.0 → 1.6.0

package/dist/src/clients/payment-checkout/apple-session.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ApplePaySession lifecycle manager.
+ * Creates the native Apple Pay payment sheet and wires merchant validation,
+ * payment authorization, and cancellation handlers.
+ */
+export type ApplePaySessionConfig = {
+    countryCode: string;
+    currencyCode: string;
+    supportedNetworks: string[];
+    totalAmount: string;
+    totalLabel: string;
+    skuId: string;
+    returnUrl: string;
+    userLoggedIn: boolean;
+    onPaymentAuthorized: (event: ApplePayJS.ApplePayPaymentAuthorizedEvent, session: ApplePaySession) => Promise<void>;
+    onCancel?: () => void;
+};
+export declare function startApplePaySession(config: ApplePaySessionConfig): void;

package/dist/src/clients/payment-checkout/apple-session.js

@@ -0,0 +1,227 @@
+// src/clients/payment-checkout/config.ts
+var runtimeConfig = null;
+var getApplePayConfig = () => runtimeConfig;
+
+// src/clients/payment-checkout/types.ts
+var ApiError = class extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`API request failed with status ${status}`);
+    this.name = "ApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+
+// src/clients/payment-checkout/index.ts
+var getWalletApiBaseUrl = () => {
+  const config = getApplePayConfig();
+  if (!config?.walletApiBaseUrl) {
+    throw new Error(
+      "[web-apple-pay] Missing walletApiBaseUrl. Call configureApplePay({ merchantId, walletApiBaseUrl, ... }) before making wallet API requests."
+    );
+  }
+  return config.walletApiBaseUrl;
+};
+var apiFetch = async (path, options = {}) => {
+  const baseUrl = getWalletApiBaseUrl();
+  const method = (options.method ?? "GET").toUpperCase();
+  const hasBody = options.body !== void 0 && options.body !== null;
+  const headers = new Headers(options.headers);
+  if (!headers.has("Accept")) {
+    headers.set("Accept", "application/json");
+  }
+  if (!headers.has("Content-Type")) {
+    if (hasBody || method !== "GET" && method !== "HEAD") {
+      headers.set("Content-Type", "application/json");
+    }
+  }
+  const response = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers
+  });
+  if (!response.ok) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      const errorBody = await response.json();
+      throw new ApiError(response.status, errorBody);
+    }
+    const errorText = await response.text();
+    throw new Error(
+      `API request failed: ${response.status} ${response.statusText} - ${errorText}`
+    );
+  }
+  return response.json();
+};
+var validateAppleMerchant = (data) => {
+  return apiFetch("/v1/wallet/validate-merchant", {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+};
+
+// src/utils/expressCheckoutRedirect.ts
+var redirectToCheckoutFallback = (params) => {
+  const url = new URL(window.location.href);
+  url.pathname = "/checkout";
+  url.searchParams.set("lmo_offer", params.skuId);
+  if (params.inlineError)
+    url.searchParams.set("inlineError", params.inlineError);
+  if (params.email) url.searchParams.set("email", params.email);
+  if (params.emailError) url.searchParams.set("emailError", params.emailError);
+  url.searchParams.set("returnUrl", params.returnUrl);
+  return url.pathname + url.search;
+};
+
+// src/utils/recaptcha.ts
+var loadRecaptchaScript = (siteKey) => {
+  return new Promise((resolve, reject) => {
+    if (typeof grecaptcha !== "undefined") return resolve();
+    const existingScript = document.querySelector(
+      'script[src*="recaptcha/api.js"]'
+    );
+    if (existingScript) {
+      existingScript.addEventListener("load", () => resolve());
+      existingScript.addEventListener(
+        "error",
+        () => reject(new Error("Failed to load existing reCAPTCHA script"))
+      );
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = `https://www.google.com/recaptcha/api.js?render=${siteKey}`;
+    script.async = true;
+    script.defer = true;
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error("Failed to load reCAPTCHA script"));
+    document.head.appendChild(script);
+  });
+};
+var getRecaptchaToken = async (action) => {
+  const siteKey = getApplePayConfig()?.recaptchaSiteKey;
+  if (!siteKey) {
+    throw new Error(
+      "[web-apple-pay] Missing recaptchaSiteKey. Call configureApplePay({ recaptchaSiteKey, ... }) before initiating Apple Pay."
+    );
+  }
+  await loadRecaptchaScript(siteKey);
+  return new Promise((resolve, reject) => {
+    grecaptcha.ready(() => {
+      grecaptcha.execute(siteKey, { action }).then(resolve).catch(reject);
+    });
+  });
+};
+
+// src/utils/expressCheckoutTracking.ts
+var EXPRESS_CHECKOUT_EVENTS = {
+  /** Wallet button displayed */
+  IMPRESSION: "express_wallet_impression",
+  /** Wallet button clicked */
+  BUTTON_CLICK: "express_wallet_click",
+  /** Apple Pay sheet opened */
+  SHEET_OPEN: "wallet_payment_sheet_open",
+  /** Payment authorised by the user in the Apple Pay sheet */
+  AUTHORISED: "wallet_payment_authorised",
+  /** Purchase completed — BFF returned success */
+  SUCCESS: "wallet_payment_success",
+  /** Payment failed — BFF returned error */
+  FAILURE: "wallet_payment_failure",
+  /** Redirect to standard checkout (any fallback path) */
+  FALLBACK_CHECKOUT: "fallback_checkout"
+};
+var emitTedlEvent = (event) => {
+  window.tedl = window.tedl ?? {};
+  window.tedl.events = window.tedl.events ?? [];
+  window.tedl.events.push(event);
+};
+var track = (action, extra) => {
+  emitTedlEvent({
+    name: "user.journey",
+    type: "checkout",
+    action,
+    info: "applepay",
+    ...extra
+  });
+};
+var trackWalletPaymentSheetOpen = (skuId) => {
+  track(EXPRESS_CHECKOUT_EVENTS.SHEET_OPEN, { sku_id: skuId });
+};
+var trackWalletPaymentAuthorised = (skuId) => {
+  track(EXPRESS_CHECKOUT_EVENTS.AUTHORISED, { sku_id: skuId });
+};
+var trackFallbackCheckout = (skuId) => {
+  track(EXPRESS_CHECKOUT_EVENTS.FALLBACK_CHECKOUT, { sku_id: skuId });
+};
+
+// src/clients/payment-checkout/messages.ts
+var MSG_PAYMENT_GENERIC_ERROR = "Something went wrong. Please check your payment and billing details and try again or contact us.";
+
+// src/clients/payment-checkout/apple-session.ts
+function startApplePaySession(config) {
+  const paymentRequest = {
+    countryCode: config.countryCode,
+    currencyCode: config.currencyCode,
+    merchantCapabilities: ["supports3DS"],
+    supportedNetworks: config.supportedNetworks,
+    total: {
+      label: config.totalLabel,
+      amount: config.totalAmount
+    },
+    requiredBillingContactFields: ["postalAddress", "name"],
+    // Only request email from Apple Pay sheet if user is NOT logged in
+    ...!config.userLoggedIn && { requiredShippingContactFields: ["email"] }
+  };
+  const session = new ApplePaySession(3, paymentRequest);
+  session.onvalidatemerchant = async (event) => {
+    try {
+      const validationHost = new URL(event.validationURL).host;
+      if (!validationHost.endsWith("apple.com")) {
+        trackFallbackCheckout(config.skuId);
+        session.abort();
+        window.location.href = redirectToCheckoutFallback({
+          skuId: config.skuId,
+          returnUrl: config.returnUrl,
+          inlineError: MSG_PAYMENT_GENERIC_ERROR
+        });
+        return;
+      }
+      const recaptchaToken = await getRecaptchaToken("verifyMerchant");
+      const response = await validateAppleMerchant({
+        validationURL: event.validationURL,
+        recaptchaToken
+      });
+      if (!response?.merchantSession) {
+        trackFallbackCheckout(config.skuId);
+        session.abort();
+        window.location.href = redirectToCheckoutFallback({
+          skuId: config.skuId,
+          returnUrl: config.returnUrl,
+          inlineError: MSG_PAYMENT_GENERIC_ERROR
+        });
+        return;
+      }
+      session.completeMerchantValidation(response.merchantSession);
+    } catch {
+      trackFallbackCheckout(config.skuId);
+      session.abort();
+      window.location.href = redirectToCheckoutFallback({
+        skuId: config.skuId,
+        returnUrl: config.returnUrl,
+        inlineError: MSG_PAYMENT_GENERIC_ERROR
+      });
+    }
+  };
+  session.onpaymentauthorized = (event) => {
+    trackWalletPaymentAuthorised(config.skuId);
+    config.onPaymentAuthorized(event, session);
+  };
+  session.oncancel = () => {
+    config.onCancel?.();
+  };
+  trackWalletPaymentSheetOpen(config.skuId);
+  session.begin();
+}
+export {
+  startApplePaySession
+};

package/dist/src/clients/payment-checkout/billing-contact-details.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Apple Pay billing contact local validator.
+ *
+ * Validates required billing fields BEFORE sending to the BFF /v1/wallet/purchase.
+ * On validation failure, throws ContactValidationError with ApplePayError[] objects
+ * that Apple uses to highlight problematic billing fields inline — keeping the sheet open.
+ */
+export type BillingValidationResult = {
+    firstName: string;
+    lastName: string;
+};
+/**
+ * Validates the billing contact from the Apple Pay wallet.
+ *
+ * @param contact - Billing address from the Apple Pay wallet
+ * @param supportedBillingCountries - Country codes the offer supports billing to
+ * @throws {ContactValidationError} when required fields are missing — Apple Pay
+ *   sheet stays open and the first error text is shown to the user as a summary
+ * @returns firstName and lastName extracted from the contact
+ */
+export declare const billingContactDetails: (contact: ApplePayJS.ApplePayPaymentContact, supportedBillingCountries: string[]) => BillingValidationResult;

package/dist/src/clients/payment-checkout/billing-contact-details.js

@@ -0,0 +1,109 @@
+// src/utils/expressCheckoutTracking.ts
+var emitTedlEvent = (event) => {
+  window.tedl = window.tedl ?? {};
+  window.tedl.events = window.tedl.events ?? [];
+  window.tedl.events.push(event);
+};
+var track = (action, extra) => {
+  emitTedlEvent({
+    name: "user.journey",
+    type: "checkout",
+    action,
+    info: "applepay",
+    ...extra
+  });
+};
+var trackValidationFieldError = (field, errorType) => {
+  track(`validation_${field}_${errorType}`, {});
+};
+
+// src/clients/payment-checkout/messages.ts
+var MSG_MISSING_REQUIRED_FIELD = "Missing required field";
+var MSG_UNSUPPORTED_BILLING_COUNTRY = "Billing country does not match offer price zone";
+var MSG_CONTACT_VALIDATION_INTERNAL = "Could not validate Apple Pay contact";
+
+// src/clients/payment-checkout/contact-validation.ts
+var pushFieldError = (errors, billingOrShippingContact = "billing", field, errorType, errorText) => {
+  const errorCode = billingOrShippingContact === "billing" ? "billingContactInvalid" : "shippingContactInvalid";
+  errors.push(new ApplePayError(errorCode, field, errorText));
+  trackValidationFieldError(field, errorType);
+  return "";
+};
+var pushRequiredFieldError = (errors, billingOrShippingContact = "billing", field) => {
+  return pushFieldError(
+    errors,
+    billingOrShippingContact,
+    field,
+    "required",
+    MSG_MISSING_REQUIRED_FIELD
+  );
+};
+var ContactValidationError = class extends Error {
+  constructor(errors) {
+    super(MSG_CONTACT_VALIDATION_INTERNAL);
+    this.errors = errors;
+  }
+};
+
+// src/clients/payment-checkout/billing-contact-details.ts
+var countriesWithoutCityField = ["KY", "CK", "NR", "TC"];
+var countriesRequiringAllFields = ["US", "CA", "GB"];
+var resolveCountryConfig = (country) => {
+  const hasCityField = !countriesWithoutCityField.includes(country);
+  const requiresStateAndPostcode = countriesRequiringAllFields.includes(country);
+  return {
+    hasCityField,
+    requiresStateAndPostcode,
+    // if there is no city field, we require state and use it in place of city
+    requiresStateField: !hasCityField || requiresStateAndPostcode
+  };
+};
+var validateAddressFields = (errors, contact, { hasCityField, requiresStateAndPostcode, requiresStateField }) => {
+  const locality = !hasCityField ? contact.administrativeArea : contact.locality;
+  if (!contact.addressLines?.at(0)?.trim()) {
+    pushRequiredFieldError(errors, "billing", "addressLines");
+  }
+  if (!locality?.trim() && hasCityField) {
+    pushRequiredFieldError(errors, "billing", "locality");
+  }
+  if (!contact.administrativeArea?.trim() && requiresStateField) {
+    pushRequiredFieldError(errors, "billing", "administrativeArea");
+  }
+  if (!contact.postalCode?.trim() && requiresStateAndPostcode) {
+    pushRequiredFieldError(errors, "billing", "postalCode");
+  }
+};
+var validateNameFields = (errors, contact) => {
+  const firstName = contact.givenName?.trim() || "";
+  const lastName = contact.familyName?.trim() || "";
+  if (!firstName || !lastName) {
+    pushRequiredFieldError(errors, "billing", "name");
+  }
+  return { firstName, lastName };
+};
+var validateCountrySupport = (errors, country, supportedBillingCountries) => {
+  if (!supportedBillingCountries.includes(country)) {
+    pushFieldError(
+      errors,
+      "billing",
+      "countryCode",
+      "not-supported",
+      MSG_UNSUPPORTED_BILLING_COUNTRY
+    );
+  }
+};
+var billingContactDetails = (contact, supportedBillingCountries) => {
+  const errors = [];
+  const country = contact.countryCode?.toUpperCase() || pushRequiredFieldError(errors, "billing", "country");
+  const config = resolveCountryConfig(country);
+  validateAddressFields(errors, contact, config);
+  const { firstName, lastName } = validateNameFields(errors, contact);
+  validateCountrySupport(errors, country, supportedBillingCountries);
+  if (errors.length > 0) {
+    throw new ContactValidationError(errors);
+  }
+  return { firstName, lastName };
+};
+export {
+  billingContactDetails
+};

package/dist/src/clients/payment-checkout/config.d.ts

@@ -1,5 +1,6 @@
 export interface ApplePayRuntimeConfig {
     merchantId: string;
+    recaptchaSiteKey?: string;
     debugBypassEnabled?: boolean;
     walletApiBaseUrl: string;
 }

package/dist/src/clients/payment-checkout/contact-validation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Apple Pay contact validation helpers.
+ * Ported from sma-checkout — helpers/contact-validation.ts
+ *
+ * pushFieldError / pushRequiredFieldError also fire TEDL analytics per field.
+ */
+import ApplePayErrorContactField = ApplePayJS.ApplePayErrorContactField;
+/**
+ * Appends an ApplePayError to the error accumulator and fires a TEDL analytics
+ * event for the failing field. Returns '' so it can be used inline with ||.
+ */
+export declare const pushFieldError: (errors: ApplePayError[], billingOrShippingContact: "billing" | "shipping" | undefined, field: ApplePayErrorContactField, errorType: "required" | "format" | "not-supported", errorText: string) => string;
+/**
+ * Convenience wrapper for required-field errors.
+ * Uses the standard 'Missing required field' message — matches sma-checkout exactly.
+ */
+export declare const pushRequiredFieldError: (errors: ApplePayError[], billingOrShippingContact: "billing" | "shipping" | undefined, field: ApplePayErrorContactField) => string;
+export declare class ContactValidationError extends Error {
+    errors: ApplePayError[];
+    constructor(errors: ApplePayError[]);
+}

package/dist/src/clients/payment-checkout/contact-validation.js

@@ -0,0 +1,50 @@
+// src/utils/expressCheckoutTracking.ts
+var emitTedlEvent = (event) => {
+  window.tedl = window.tedl ?? {};
+  window.tedl.events = window.tedl.events ?? [];
+  window.tedl.events.push(event);
+};
+var track = (action, extra) => {
+  emitTedlEvent({
+    name: "user.journey",
+    type: "checkout",
+    action,
+    info: "applepay",
+    ...extra
+  });
+};
+var trackValidationFieldError = (field, errorType) => {
+  track(`validation_${field}_${errorType}`, {});
+};
+
+// src/clients/payment-checkout/messages.ts
+var MSG_MISSING_REQUIRED_FIELD = "Missing required field";
+var MSG_CONTACT_VALIDATION_INTERNAL = "Could not validate Apple Pay contact";
+
+// src/clients/payment-checkout/contact-validation.ts
+var pushFieldError = (errors, billingOrShippingContact = "billing", field, errorType, errorText) => {
+  const errorCode = billingOrShippingContact === "billing" ? "billingContactInvalid" : "shippingContactInvalid";
+  errors.push(new ApplePayError(errorCode, field, errorText));
+  trackValidationFieldError(field, errorType);
+  return "";
+};
+var pushRequiredFieldError = (errors, billingOrShippingContact = "billing", field) => {
+  return pushFieldError(
+    errors,
+    billingOrShippingContact,
+    field,
+    "required",
+    MSG_MISSING_REQUIRED_FIELD
+  );
+};
+var ContactValidationError = class extends Error {
+  constructor(errors) {
+    super(MSG_CONTACT_VALIDATION_INTERNAL);
+    this.errors = errors;
+  }
+};
+export {
+  ContactValidationError,
+  pushFieldError,
+  pushRequiredFieldError
+};

package/dist/src/clients/payment-checkout/index.d.ts

@@ -1 +1,5 @@
+import type { PaymentOptionsRequest, PaymentOptionsResponse, PurchaseRequest, PurchaseResponse, ValidateMerchantRequest, ValidateMerchantResponse } from './types';
 export declare const apiFetch: <T>(path: string, options?: RequestInit) => Promise<T>;
+export declare const getPaymentOptions: (data: PaymentOptionsRequest) => Promise<PaymentOptionsResponse>;
+export declare const validateAppleMerchant: (data: ValidateMerchantRequest) => Promise<ValidateMerchantResponse>;
+export declare const performPurchase: (data: PurchaseRequest) => Promise<PurchaseResponse>;

package/dist/src/clients/payment-checkout/index.js

@@ -54,6 +54,30 @@ var apiFetch = async (path, options = {}) => {
   }
   return response.json();
 };
+var getPaymentOptions = (data) => {
+  const { sku, countryCode, currencyCode, checkoutUrl } = data;
+  const params = new URLSearchParams({ checkoutUrl });
+  return apiFetch(
+    `/ecomb2c/v1/payment-options/sku/${sku}/${countryCode}/${currencyCode}?${params}`,
+    { method: "GET" }
+  );
+};
+var validateAppleMerchant = (data) => {
+  return apiFetch("/v1/wallet/validate-merchant", {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+};
+var performPurchase = (data) => {
+  return apiFetch("/v1/wallet/purchase", {
+    method: "POST",
+    body: JSON.stringify(data),
+    credentials: "include"
+  });
+};
 export {
-  apiFetch
+  apiFetch,
+  getPaymentOptions,
+  performPurchase,
+  validateAppleMerchant
 };

package/dist/src/clients/payment-checkout/messages.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Canonical user-facing error messages for the Apple Pay Express Checkout flow.
+ *
+ * All copy here is verified against sma-checkout (src/actions/constants/index.ts
+ * and handlers/create-on-payment-authorized-handler/) to ensure parity with the
+ * reference implementation. Update both repos if copy changes.
+ */
+/** Shown when a required Apple Pay contact field is absent. */
+export declare const MSG_MISSING_REQUIRED_FIELD = "Missing required field";
+/** Shown when the email address format is invalid (matches sma-checkout FormErrorMessages.EMAIL_WRONG_FORMAT). */
+export declare const MSG_EMAIL_WRONG_FORMAT = "That email doesn\u2019t look right. Please enter a valid email address.";
+/** Shown when the email address exceeds 80 characters (matches sma-checkout FormErrorMessages.MAX_80_CHARS). */
+export declare const MSG_EMAIL_TOO_LONG = "This field must be 80 characters or less.";
+/** Shown when the billing country is not in the supported list for the offer. */
+export declare const MSG_UNSUPPORTED_BILLING_COUNTRY = "Billing country does not match offer price zone";
+/**
+ * Generic fallback error shown to the user when merchant validation or the
+ * purchase call fails. Redirected as an inlineError on the checkout fallback page.
+ * Matches sma-checkout GENERIC_ERROR_MSG pattern.
+ */
+export declare const MSG_PAYMENT_GENERIC_ERROR = "Something went wrong. Please check your payment and billing details and try again or contact us.";
+/**
+ * Shown when a reCAPTCHA security check fails.
+ * Matches sma-checkout reference: handlers/create-on-payment-authorized-handler/subscribe.
+ */
+export declare const MSG_RECAPTCHA_VALIDATION_FAILED = "Security check failed. Please try again.";
+/**
+ * Shown when the BFF returns an EMAIL_COLLISION error (account already exists).
+ * Matches sma-checkout L103-104.
+ */
+export declare const MSG_EMAIL_COLLISION = "This email address is already linked to an account. Please log in, or try a different email address.";
+/** Internal ContactValidationError message — not shown to the user directly. */
+export declare const MSG_CONTACT_VALIDATION_INTERNAL = "Could not validate Apple Pay contact";

package/dist/src/clients/payment-checkout/messages.js

@@ -0,0 +1,19 @@
+// src/clients/payment-checkout/messages.ts
+var MSG_MISSING_REQUIRED_FIELD = "Missing required field";
+var MSG_EMAIL_WRONG_FORMAT = "That email doesn\u2019t look right. Please enter a valid email address.";
+var MSG_EMAIL_TOO_LONG = "This field must be 80 characters or less.";
+var MSG_UNSUPPORTED_BILLING_COUNTRY = "Billing country does not match offer price zone";
+var MSG_PAYMENT_GENERIC_ERROR = "Something went wrong. Please check your payment and billing details and try again or contact us.";
+var MSG_RECAPTCHA_VALIDATION_FAILED = "Security check failed. Please try again.";
+var MSG_EMAIL_COLLISION = "This email address is already linked to an account. Please log in, or try a different email address.";
+var MSG_CONTACT_VALIDATION_INTERNAL = "Could not validate Apple Pay contact";
+export {
+  MSG_CONTACT_VALIDATION_INTERNAL,
+  MSG_EMAIL_COLLISION,
+  MSG_EMAIL_TOO_LONG,
+  MSG_EMAIL_WRONG_FORMAT,
+  MSG_MISSING_REQUIRED_FIELD,
+  MSG_PAYMENT_GENERIC_ERROR,
+  MSG_RECAPTCHA_VALIDATION_FAILED,
+  MSG_UNSUPPORTED_BILLING_COUNTRY
+};

package/dist/src/clients/payment-checkout/payment-handler.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Central onpaymentauthorized orchestrator.
+ *
+ * The BFF /v1/wallet/purchase orchestrates ALL backend logic:
+ *   - Eligibility check
+ *   - Passwordless user registration (if anonymous)
+ *   - Basket creation
+ *   - Payment finalization
+ *
+ * This handler is responsible for:
+ *   1. Local billing/shipping contact validation (keeps Apple Pay sheet open on error)
+ *   2. Calling the single /v1/wallet/purchase endpoint
+ *   3. Handling success → redirect to /checkout/complete
+ *   4. Handling structured BFF errors → deterministic UI actions per errorType
+ */
+import type { SessionResponse } from './types';
+export type PaymentHandlerConfig = {
+    skuId: string;
+    country: string;
+    returnUrl: string;
+    /**
+     * Optional `&country=` query param captured from the page URL at the moment
+     * the payment sheet was authorised (via `buildQueryString()`).
+     * Appended verbatim to the checkout-complete and fallback redirect URLs so
+     * the country context is preserved across the redirect.
+     * e.g. `'&country=US'`, `'&country=GB%2FIE'`, or `''` when absent.
+     */
+    queryString?: string;
+    supportedBillingCountries: string[];
+    recaptchaTokens: {
+        checkEligibility: string;
+        newBasket: string;
+        registerUser: string;
+    };
+};
+export declare function handlePaymentAuthorized(event: ApplePayJS.ApplePayPaymentAuthorizedEvent, session: ApplePaySession, sessionData: SessionResponse, config: PaymentHandlerConfig): Promise<void>;