@primer-io/react-native 2.45.0 → 3.0.0-beta.0

package/src/Components/types/PrimerCardFormTypes.ts

@@ -0,0 +1,19 @@
+import type { StyleProp, ViewStyle } from 'react-native';
+
+/** Merchant-facing props for the composed `<PrimerCardForm />` component. */
+export interface PrimerCardFormProps {
+  /**
+   * Fires when the user hits the return key on the last input. The host screen
+   * typically routes this to the same handler that its Pay button uses.
+   */
+  onSubmit?: () => void;
+  /**
+   * Focus the card number field after mount. Deferred until interactions settle so
+   * the keyboard opens after any nav transition, not during it.
+   */
+  autoFocus?: boolean;
+  /** Optional outer container style. */
+  style?: StyleProp<ViewStyle>;
+  /** Test ID root for the form. Nested elements derive suffixed IDs. */
+  testID?: string;
+}

package/src/Components/types/PrimerCheckoutProviderTypes.ts

@@ -0,0 +1,168 @@
+import type { ReactNode } from 'react';
+import type { PrimerSettings } from '../../models/PrimerSettings';
+import type { PrimerError } from '../../models/PrimerError';
+import type { PrimerAddress, PrimerClientSession } from '../../models/PrimerClientSession';
+import type { PrimerCheckoutData } from '../../models/PrimerCheckoutData';
+import type { PrimerCheckoutPaymentMethodData } from '../../models/PrimerCheckoutPaymentMethodData';
+import type { PrimerPaymentMethodTokenData } from '../../models/PrimerPaymentMethodTokenData';
+import type { PrimerRawData } from '../../models/PrimerRawData';
+import type { PrimerBinData } from '../../models/PrimerBinData';
+import type { PrimerInputElementType } from '../../models/PrimerInputElementType';
+import type {
+  PrimerHeadlessUniversalCheckoutResumeHandler,
+  PrimerPaymentCreationHandler,
+} from '../../models/PrimerHandlers';
+import type { IPrimerHeadlessUniversalCheckoutPaymentMethod } from '../../models/PrimerHeadlessUniversalCheckoutPaymentMethod';
+import type { PrimerPaymentMethodAsset, PrimerPaymentMethodNativeView } from '../../models/PrimerPaymentMethodResource';
+import type { PrimerVaultedPaymentMethod } from '../../models/PrimerVaultedPaymentMethod';
+import type { PrimerVaultedPaymentMethodAdditionalData } from '../../models/PrimerVaultedPaymentMethodAdditionalData';
+import type { PrimerThemeOverride } from '../internal/theme/types';
+import type { CardFormErrors } from './CardFormTypes';
+import type { CardNetworkId } from '../internal/cardNetwork';
+
+export interface PrimerCheckoutProviderProps {
+  clientToken: string;
+  settings?: PrimerSettings;
+  theme?: PrimerThemeOverride;
+  onCheckoutComplete?: (checkoutData: PrimerCheckoutData) => void;
+  onTokenizationSuccess?: (
+    paymentMethodTokenData: PrimerPaymentMethodTokenData,
+    handler: PrimerHeadlessUniversalCheckoutResumeHandler
+  ) => void;
+  onBeforePaymentCreate?: (
+    checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData,
+    handler: PrimerPaymentCreationHandler
+  ) => void;
+  onError?: (error: PrimerError, checkoutData: PrimerCheckoutData | null) => void;
+  children?: ReactNode;
+}
+
+/** Outcome of the most recent payment attempt within a checkout session. */
+export type PaymentOutcome =
+  | { status: 'success'; data: PrimerCheckoutData }
+  | { status: 'error'; error: PrimerError; data: PrimerCheckoutData | null };
+
+/** Validation + metadata state surfaced by the active raw-data manager. */
+export interface CardFormState {
+  isValid: boolean;
+  errors: CardFormErrors;
+  binData: PrimerBinData | null;
+  metadata: unknown;
+  requiredFields: PrimerInputElementType[];
+}
+
+export interface PrimerCheckoutContextValue {
+  // --- Session state ---
+  isReady: boolean;
+  /** Init-time errors only (before `isReady`). Payment-time errors land in `paymentOutcome`. */
+  error: PrimerError | null;
+  clientSession: PrimerClientSession | null;
+  /**
+   * Ordered list of card networks the merchant accepts for the session, e.g. `['VISA', 'MASTERCARD']`.
+   * `null` until the bridge resolves or when the session has no `paymentMethod`; `[]` when explicitly empty.
+   */
+  acceptedCardNetworks: string[] | null;
+  availablePaymentMethods: IPrimerHeadlessUniversalCheckoutPaymentMethod[];
+  paymentMethodResources: Array<PrimerPaymentMethodAsset | PrimerPaymentMethodNativeView>;
+  isLoadingResources: boolean;
+  resourcesError: Error | null;
+  /** Settings the merchant passed to the provider. Needed for UI-option toggles. */
+  settings: PrimerSettings | undefined;
+
+  // --- Native-UI methods (Google Pay today; Apple Pay / PayPal / web-redirect APMs later) ---
+  /**
+   * Which native-UI method is currently in flight, or `null`. Backs each method's `isLoading` flag.
+   * Merchants use `usePrimerPaymentMethod(type)`, not this directly.
+   */
+  nativeUiInFlightType: string | null;
+  /** Start a native-UI method by payment-method type. Rejects if the method is unavailable. */
+  startNativeUI: (paymentMethodType: string) => Promise<void>;
+  /** Cancel an in-flight native-UI attempt (best-effort; cannot force-close the system sheet). */
+  cancelNativeUI: (paymentMethodType: string) => void;
+
+  // --- Active payment attempt ---
+  /** Outcome of the most recent payment attempt; `null` before any submit. */
+  paymentOutcome: PaymentOutcome | null;
+  /** The payment method whose raw-data manager is currently active. */
+  activeMethod: string | null;
+  /** Validation + metadata state from the active raw-data manager. */
+  cardFormState: CardFormState;
+
+  // --- Vaulted payment methods ---
+  vaultedMethods: PrimerVaultedPaymentMethod[];
+  /** Brand-icon URIs keyed by vaulted-method id, resolved via AssetsManager at fetch time. */
+  vaultedIconUrisById: Record<string, string | undefined>;
+  isLoadingVaulted: boolean;
+  vaultedError: Error | null;
+  /** Id of the user-selected vaulted method, or `null` to fall back to the first method. */
+  activeVaultedMethodId: string | null;
+  /** When set to `'expanded'`, force the method-selection view to show APMs even after the shopper has switched vaulted method. Cleared automatically on subsequent selection changes. */
+  vaultDisplayOverride: 'expanded' | null;
+  /**
+   * Whether the merchant's session has `paymentMethods.PAYMENT_CARD.options.captureVaultedCardCvv = true`.
+   * Read once after `vm.configure()` resolves and cached for the provider's lifetime — flag flips
+   * mid-session are picked up on the next provider re-initialization.
+   */
+  requiresVaultedCardCvv: boolean;
+  /**
+   * Whether the inline CVV input row is currently rendered inside the active vault tile.
+   * Lifted to the provider so the sheet-height calculation in `MethodSelectionScreen` can react
+   * (the entered CVV digits stay local to `PrimerVaultedPaymentMethod` for security).
+   */
+  cvvInputVisible: boolean;
+
+  // --- Actions ---
+  /** Register/deregister the active payment method. Pass `null` to tear down. */
+  setActiveMethod: (method: string | null) => void;
+  /**
+   * Shopper-picked card network for co-badged cards. `null` until the shopper makes
+   * a choice in the popover. Persists across re-renders / hook callers (lives on the
+   * provider, not on individual hook instances).
+   */
+  selectedCardNetwork: CardNetworkId | null;
+  /** Forward raw data to the active native manager. */
+  setRawData: (data: PrimerRawData) => Promise<void>;
+  /**
+   * Forward a billing address to the active native manager. Dispatched as a separate
+   * client-session action, independent of raw card data, before submit.
+   */
+  setBillingAddress: (address: PrimerAddress) => Promise<void>;
+  /**
+   * Set the shopper-chosen card network on the active card form (co-badged cards).
+   * The provider merges the pick into every subsequent `setRawData` payload, so the
+   * choice survives keystroke updates.
+   */
+  selectCardNetwork: (identifier: CardNetworkId) => Promise<void>;
+  /** Fire the active manager's submit. First-attempt path. */
+  submit: () => Promise<void>;
+  /**
+   * Retry the last submit. Reconfigures the manager, re-sends the last raw data, then submits.
+   * The reconfigure is defensive for iOS: `RawDataManager.swift:237` nullifies the delegate on
+   * successful tokenization, so any post-tokenize failure would otherwise have no delegate
+   * to surface a retry's outcome. Reconfigure rebuilds the delegate binding. Harmless on Android.
+   */
+  retry: () => Promise<void>;
+  /** Clear the last payment outcome (e.g., when leaving the error screen). */
+  clearPaymentOutcome: () => void;
+  /**
+   * Start the payment flow for a vaulted payment method by id.
+   * If `additionalData` is supplied (e.g. `{ cvv }` for CVV-recapture), the request is sent through
+   * the with-additional-data bridge path; otherwise the no-CVV bridge path is used.
+   */
+  payFromVault: (
+    vaultedPaymentMethodId: string,
+    additionalData?: PrimerVaultedPaymentMethodAdditionalData
+  ) => Promise<void>;
+  /** Make `id` the active vaulted method. No-op if it already matches the current active id. */
+  selectVaultedMethodId: (id: string) => void;
+  /** Force the method-selection view back to expanded layout while preserving the user's selection. */
+  requestExpandedVaultDisplay: () => void;
+  /** Toggle the inline CVV input row's visibility on the active vault tile. */
+  setCvvInputVisible: (visible: boolean) => void;
+  /**
+   * Delete a vaulted payment method server-side, refresh the local list, and promote the first
+   * remaining method into the active slot if the deleted one was active. Matches iOS / Android
+   * Checkout Components behaviour. Rejects with `{ errorId, description }` on bridge failure.
+   */
+  deleteVaultedPaymentMethod: (id: string) => Promise<void>;
+}

package/src/Components/types/PrimerPaymentMethodListTypes.ts

@@ -0,0 +1,24 @@
+import type { ViewStyle } from 'react-native';
+import type { PaymentMethodItem } from './PaymentMethodTypes';
+
+export interface PrimerPaymentMethodListProps {
+  /** Pre-fetched payment methods. When provided, the list skips its internal usePrimerPaymentMethods() call. */
+  data?: PaymentMethodItem[];
+  /** Whitelist: only show these payment method types */
+  include?: string[];
+  /** Blacklist: hide these payment method types */
+  exclude?: string[];
+  /** Called when a payment method button is tapped */
+  onSelect: (method: PaymentMethodItem) => void;
+  /** Called when payment methods finish loading */
+  onLoad?: (methods: PaymentMethodItem[]) => void;
+  /** Container style override */
+  style?: ViewStyle;
+}
+
+export interface PaymentMethodButtonProps {
+  /** The payment method data to render */
+  item: PaymentMethodItem;
+  /** Tap handler */
+  onPress: () => void;
+}

package/src/Components/types/PrimerPaymentMethodTypes.ts

@@ -0,0 +1,55 @@
+import type { PaymentOutcome } from './PrimerCheckoutProviderTypes';
+
+/**
+ * Why a payment method is unavailable. Coarse `{ code, message }`; the codes are method-specific
+ * (e.g. Google Pay: `NOT_READY` / `PLATFORM_NOT_SUPPORTED`).
+ */
+export interface PaymentMethodAvailabilityError {
+  code: string;
+  message: string;
+}
+
+/**
+ * A native-UI method (Google Pay today; Apple Pay / PayPal / web-redirect APMs later). `start()`
+ * presents the native sheet / browser; the outcome arrives via `paymentOutcome`. Render nothing
+ * when `!isAvailable`.
+ */
+export interface NativeUiPaymentMethod {
+  kind: 'nativeUi';
+  readonly isAvailable: boolean;
+  /** True from `start()` until a terminal outcome (a cancel counts as an error). */
+  readonly isLoading: boolean;
+  readonly paymentOutcome: PaymentOutcome | null;
+  readonly availabilityError: PaymentMethodAvailabilityError | null;
+  /** Present the native UI. Rejects if `!isAvailable`. Outcome arrives via `paymentOutcome`. */
+  start(): Promise<void>;
+  /** Cancel an in-flight attempt (best-effort; cannot force-close a system sheet). */
+  cancel(): void;
+  clearPaymentOutcome(): void;
+}
+
+/**
+ * The card method. `start()` opens the default card form; the field-level surface (custom layouts,
+ * validation, co-badge) lives on `usePrimerCardForm` / `PrimerCardForm`. Use one or the other for a
+ * given card on screen — not both.
+ */
+export interface CardPaymentMethod {
+  kind: 'card';
+  readonly isAvailable: boolean;
+  /** Activate the card form's raw-data manager. Does not navigate — render the form yourself. */
+  start(): void;
+  clearPaymentOutcome(): void;
+}
+
+/**
+ * Can't be driven here: either a type not wired into Components yet, OR a known method that isn't
+ * in the current session (its category is unknown). Either way it can't be started — render
+ * nothing / disabled.
+ */
+export interface UnsupportedPaymentMethod {
+  kind: 'unsupported';
+  readonly isAvailable: false;
+}
+
+/** Return value of {@link usePrimerPaymentMethod}; narrow on `kind`. */
+export type UsePrimerPaymentMethodReturn = NativeUiPaymentMethod | CardPaymentMethod | UnsupportedPaymentMethod;

package/src/Components/types/VaultedPaymentMethodTypes.ts

@@ -0,0 +1,74 @@
+import type { StyleProp, ViewStyle } from 'react-native';
+import type { PrimerVaultedPaymentMethod } from '../../models/PrimerVaultedPaymentMethod';
+import type { PrimerVaultedPaymentMethodAdditionalData } from '../../models/PrimerVaultedPaymentMethodAdditionalData';
+
+/** View-model for a single vaulted payment method, with derived display fields. */
+export interface VaultedPaymentMethodItem {
+  id: string;
+  paymentMethodType: string;
+  paymentInstrumentType: string;
+  /** Human-readable cardholder name (card vaults only). */
+  cardholderName?: string;
+  /** Last 4 digits as a string, masked-format ready. Card / bank-account vaults only. */
+  last4?: string;
+  /** Two-digit zero-padded expiry month. Card vaults only. */
+  expiryMonth?: string;
+  /** Two-digit expiry year (e.g. "26"). Card vaults only. */
+  expiryYear?: string;
+  /** Title-cased brand name for display (e.g. "Mastercard"). Card vaults only. */
+  brandName?: string;
+  /** Local file URI for the brand icon, resolved via AssetsManager. Card vaults only. */
+  brandIconUri?: string;
+  /** The underlying native method, preserved for consumers that need raw fields. */
+  rawMethod: PrimerVaultedPaymentMethod;
+}
+
+/** UI mode for the vault block on the method-selection surface. */
+export type VaultDisplayMode = 'expanded' | 'lite';
+
+export interface UsePrimerVaultManagerReturn {
+  vaultedMethods: VaultedPaymentMethodItem[];
+  /** The method that should be displayed when only one row is rendered. `null` when none exist. */
+  primaryMethod: VaultedPaymentMethodItem | null;
+  /** First method on the session — the "default" — independent of any user override. */
+  originalDefault: VaultedPaymentMethodItem | null;
+  /** The method the Pay button should charge — user-selected if any, else originalDefault. */
+  activeMethod: VaultedPaymentMethodItem | null;
+  /** `'lite'` once the shopper has actively switched off the default, unless they revert via Show other ways to pay. */
+  vaultDisplayMode: VaultDisplayMode;
+  isLoading: boolean;
+  error: Error | null;
+  /**
+   * Whether the merchant's session has CVV-recapture enabled for vaulted cards
+   * (`paymentMethods.PAYMENT_CARD.options.captureVaultedCardCvv = true`).
+   */
+  requiresVaultedCardCvv: boolean;
+  /** Whether the inline CVV input row is currently rendered inside the active vault tile. */
+  cvvInputVisible: boolean;
+  /**
+   * Start payment for `activeMethod`. No-op when none is available.
+   * If `additionalData` is supplied (e.g. `{ cvv }` for CVV-recapture), it is forwarded to the
+   * native vault-payment bridge.
+   */
+  pay: (additionalData?: PrimerVaultedPaymentMethodAdditionalData) => Promise<void>;
+  /** Start payment for a specific vaulted method id, with optional CVV-recapture additional data. */
+  payById: (id: string, additionalData?: PrimerVaultedPaymentMethodAdditionalData) => Promise<void>;
+  /** Make `id` the active method. No-op when `id` matches the current active method id. */
+  selectVaultedMethodId: (id: string) => void;
+  /** Override `vaultDisplayMode` to `'expanded'` while preserving `activeMethod`. */
+  requestExpandedVaultDisplay: () => void;
+  /**
+   * Delete a vaulted payment method. On success the local list refreshes and, if the deleted
+   * method was active, the first remaining method becomes the new active selection. Rejects
+   * with `{ errorId, description }` on bridge failure so callers can show a toast.
+   */
+  deleteVaultedPaymentMethod: (id: string) => Promise<void>;
+}
+
+export interface PrimerVaultedPaymentMethodProps {
+  /** Optional override for the row data. Defaults to `usePrimerVaultManager().primaryMethod`. */
+  data?: VaultedPaymentMethodItem | null;
+  /** Optional override for the Pay handler. Defaults to the hook's `pay`. */
+  onPay?: (method: VaultedPaymentMethodItem) => void;
+  style?: StyleProp<ViewStyle>;
+}

package/src/HeadlessUniversalCheckout/Managers/AssetsManager.ts

@@ -1,6 +1,25 @@
-import type { IPrimerPaymentMethodResource as Resource } from '../../models/PrimerPaymentMethodResource';
-import type { IPrimerAsset as Asset } from '../../models/PrimerPaymentMethodResource';
 import { NativeModules } from 'react-native';
+import type {
+  IPrimerAsset as Asset,
+  PrimerPaymentMethodAsset,
+  PrimerPaymentMethodNativeView,
+} from '../../models/PrimerPaymentMethodResource';
+
+type Resource = PrimerPaymentMethodAsset | PrimerPaymentMethodNativeView;
+
+/**
+ * Raw bridge shape emitted by native `getCardNetworkTraits`.
+ * iOS resolves `null` for networks without validation (bancontact, cartesBancaires, eftpos, unknown);
+ * Android always resolves a dict (Type.OTHER fallback) — consumers coalesce both to a default descriptor.
+ */
+export interface CardNetworkTraits {
+  cardNetwork: string;
+  displayName: string;
+  panLengths: number[];
+  gapPattern: number[];
+  cvvLength: number;
+  cvvLabel: string;
+}
 
 const { RNTPrimerHeadlessUniversalCheckoutAssetsManager } = NativeModules;
 
@@ -26,6 +45,23 @@ class PrimerHeadlessUniversalCheckoutAssetsManager {
     });
   }
 
+  async getCardNetworkTraits(cardNetwork: string): Promise<CardNetworkTraits | null> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const data = await RNTPrimerHeadlessUniversalCheckoutAssetsManager.getCardNetworkTraits(cardNetwork);
+        resolve(data ?? null);
+      } catch (err) {
+        console.error(err);
+        reject(err);
+      }
+    });
+  }
+
+  async getOrderedAllowedCardNetworks(): Promise<string[] | null> {
+    const data = await RNTPrimerHeadlessUniversalCheckoutAssetsManager.getOrderedAllowedCardNetworks();
+    return (data?.networks ?? null) as string[] | null;
+  }
+
   /**
    * @deprecated Use getPaymentMethodResource instead
    */

package/src/HeadlessUniversalCheckout/Managers/PaymentMethodManagers/AchManager.ts

@@ -98,37 +98,37 @@ export class PrimerHeadlessUniversalCheckoutAchManager {
 
   private async configureListeners(props: AchManagerProps): Promise<void> {
     if (props?.onStep) {
-      this.addListener('onStep', (data) => {
+      void this.addListener('onStep', (data) => {
         props.onStep?.(data);
       });
     }
 
     if (props?.onInvalid) {
-      this.addListener('onInvalid', (data) => {
+      void this.addListener('onInvalid', (data) => {
         props.onInvalid?.(data);
       });
     }
 
     if (props?.onError) {
-      this.addListener('onError', (data) => {
+      void this.addListener('onError', (data) => {
         props.onError?.(data);
       });
     }
 
     if (props?.onValid) {
-      this.addListener('onValid', (data) => {
+      void this.addListener('onValid', (data) => {
         props.onValid?.(data);
       });
     }
 
     if (props?.onValidating) {
-      this.addListener('onValidating', (data) => {
+      void this.addListener('onValidating', (data) => {
         props.onValidating?.(data);
       });
     }
 
     if (props?.onValidationError) {
-      this.addListener('onValidationError', (data) => {
+      void this.addListener('onValidationError', (data) => {
         props.onValidationError?.(data);
       });
     }

package/src/HeadlessUniversalCheckout/Managers/PaymentMethodManagers/ComponentWithRedirectManager.ts

@@ -119,37 +119,37 @@ export class PrimerHeadlessUniversalCheckoutComponentWithRedirectManager {
 
   private async configureListeners(props: ComponentWithRedirectManagerProps): Promise<void> {
     if (props?.onStep) {
-      this.addListener('onStep', (data) => {
+      void this.addListener('onStep', (data) => {
         props.onStep?.(data);
       });
     }
 
     if (props?.onInvalid) {
-      this.addListener('onInvalid', (data) => {
+      void this.addListener('onInvalid', (data) => {
         props.onInvalid?.(data);
       });
     }
 
     if (props?.onError) {
-      this.addListener('onError', (data) => {
+      void this.addListener('onError', (data) => {
         props.onError?.(data);
       });
     }
 
     if (props?.onValid) {
-      this.addListener('onValid', (data) => {
+      void this.addListener('onValid', (data) => {
         props.onValid?.(data);
       });
     }
 
     if (props?.onValidating) {
-      this.addListener('onValidating', (data) => {
+      void this.addListener('onValidating', (data) => {
         props.onValidating?.(data);
       });
     }
 
     if (props?.onValidationError) {
-      this.addListener('onValidationError', (data) => {
+      void this.addListener('onValidationError', (data) => {
         props.onValidationError?.(data);
       });
     }

package/src/HeadlessUniversalCheckout/Managers/PaymentMethodManagers/RawDataManager.ts

@@ -5,6 +5,7 @@ import type { PrimerInitializationData } from '../../../models/PrimerInitializat
 import { PrimerError } from '../../../models/PrimerError';
 import type { PrimerInputElementType } from '../../../models/PrimerInputElementType';
 import type { PrimerBinData } from '../../../models/PrimerBinData';
+import type { PrimerAddress } from '../../../models/PrimerClientSession';
 
 const { RNTPrimerHeadlessUniversalCheckoutRawDataManager } = NativeModules;
 const eventEmitter = new NativeEventEmitter(RNTPrimerHeadlessUniversalCheckoutRawDataManager);
@@ -52,6 +53,14 @@ class PrimerHeadlessUniversalCheckoutRawDataManager {
   }
 
   async configureListeners(): Promise<void> {
+    // Drop previous subscriptions so calling configure() multiple times (e.g. the
+    // reconfigure-on-retry pattern in Checkout Components) doesn't stack duplicate
+    // event handlers on the shared module emitter.
+    for (const sub of this.subscriptions) {
+      sub.remove();
+    }
+    this.subscriptions = [];
+
     //@ts-ignore
     if (this.options?.onMetadataChange) {
       const sub = await this.addListener('onMetadataChange', (data) => {
@@ -148,6 +157,28 @@ class PrimerHeadlessUniversalCheckoutRawDataManager {
     });
   }
 
+  setBillingAddress(address: PrimerAddress): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      if (this.options?.paymentMethodType) {
+        try {
+          await RNTPrimerHeadlessUniversalCheckoutRawDataManager.setBillingAddress(JSON.stringify(address));
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      } else {
+        const err = new PrimerError(
+          'manager-not-configured',
+          undefined,
+          'HeadlessUniversalCheckoutRawDataManager has not been configured',
+          'Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.',
+          undefined
+        );
+        reject(err);
+      }
+    });
+  }
+
   cleanUp(): Promise<void> {
     return new Promise(async (resolve, reject) => {
       if (this.options?.paymentMethodType) {

package/src/HeadlessUniversalCheckout/Managers/VaultManager.ts

@@ -96,6 +96,18 @@ class PrimerHeadlessUniversalCheckoutVaultManager {
       }
     });
   }
+
+  async requiresVaultedCardCvv(): Promise<boolean> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const value: boolean = await RNPrimerHeadlessUniversalCheckoutVaultManager.requiresVaultedCardCvv();
+        resolve(value);
+      } catch (err) {
+        console.error(err);
+        reject(err);
+      }
+    });
+  }
 }
 
 // Convert accountNumberLastFourDigits to accountNumberLast4Digits when present

package/src/HeadlessUniversalCheckout/PrimerHeadlessUniversalCheckout.ts

@@ -23,14 +23,14 @@ import type {
 const tokenizationHandler: PrimerHeadlessUniversalCheckoutResumeHandler = {
   continueWithNewClientToken: async (newClientToken: string) => {
     try {
-      RNPrimerHeadlessUniversalCheckout.handleTokenizationNewClientToken(newClientToken);
+      await RNPrimerHeadlessUniversalCheckout.handleTokenizationNewClientToken(newClientToken);
     } catch (err) {
       console.error(err);
     }
   },
 
   complete: () => {
-    RNPrimerHeadlessUniversalCheckout.handleCompleteFlow();
+    void RNPrimerHeadlessUniversalCheckout.handleCompleteFlow();
   },
 };
 
@@ -39,14 +39,14 @@ const tokenizationHandler: PrimerHeadlessUniversalCheckoutResumeHandler = {
 const resumeHandler: PrimerHeadlessUniversalCheckoutResumeHandler = {
   continueWithNewClientToken: async (newClientToken: string) => {
     try {
-      RNPrimerHeadlessUniversalCheckout.handleResumeWithNewClientToken(newClientToken);
+      await RNPrimerHeadlessUniversalCheckout.handleResumeWithNewClientToken(newClientToken);
     } catch (err) {
       console.error(err);
     }
   },
 
   complete: () => {
-    RNPrimerHeadlessUniversalCheckout.handleCompleteFlow();
+    void RNPrimerHeadlessUniversalCheckout.handleCompleteFlow();
   },
 };
 
@@ -55,7 +55,7 @@ const resumeHandler: PrimerHeadlessUniversalCheckoutResumeHandler = {
 const paymentCreationHandler: PrimerPaymentCreationHandler = {
   abortPaymentCreation: async (errorMessage: string) => {
     try {
-      RNPrimerHeadlessUniversalCheckout.handlePaymentCreationAbort(errorMessage);
+      await RNPrimerHeadlessUniversalCheckout.handlePaymentCreationAbort(errorMessage);
     } catch (err) {
       console.error(err);
     }
@@ -63,7 +63,7 @@ const paymentCreationHandler: PrimerPaymentCreationHandler = {
 
   continuePaymentCreation: async () => {
     try {
-      RNPrimerHeadlessUniversalCheckout.handlePaymentCreationContinue();
+      await RNPrimerHeadlessUniversalCheckout.handlePaymentCreationContinue();
     } catch (err) {
       console.error(err);
     }