@primer-io/react-native 2.16.2 → 2.17.0-rc.1

package/src/Primer.ts

@@ -1,13 +1,14 @@
 import type { PrimerCheckoutData } from './models/PrimerCheckoutData';
-import type { PrimerSessionIntent } from './models/PrimerSessionIntent';
 import type { PrimerSettings } from './models/PrimerSettings';
 import RNPrimer from './RNPrimer';
 import type { PrimerCheckoutPaymentMethodData } from './models/PrimerCheckoutPaymentMethodData';
 import type { PrimerClientSession } from './models/PrimerClientSession';
 import type { PrimerPaymentMethodTokenData } from './models/PrimerPaymentMethodTokenData';
 import { PrimerError } from './models/PrimerError';
-import type { IPrimer, PrimerErrorHandler, PrimerPaymentCreationHandler, PrimerResumeHandler, PrimerTokenizationHandler } from './models/PrimerInterfaces';
 import type { PrimerCheckoutAdditionalInfo } from './models/PrimerCheckoutAdditionalInfo';
+import type { PrimerErrorHandler, PrimerPaymentCreationHandler, PrimerResumeHandler, PrimerTokenizationHandler } from './models/PrimerHandlers';
+import type { IPrimer } from './models/PrimerInterfaces';
+import type { PrimerImplementedRNCallbacks } from './models/PrimerImplementedRNCallbacks';
 
 ///////////////////////////////////////////
 // DECISION HANDLERS
@@ -108,80 +109,88 @@ async function configureListeners(): Promise<void> {
     try {
       RNPrimer.removeAllListeners();
 
-      let implementedRNCallbacks: any = {
-        onCheckoutComplete: (primerSettings?.onCheckoutComplete !== undefined),
-        onBeforePaymentCreate: (primerSettings?.onBeforePaymentCreate !== undefined),
-        onBeforeClientSessionUpdate: (primerSettings?.onBeforeClientSessionUpdate !== undefined),
-        onClientSessionUpdate: (primerSettings?.onClientSessionUpdate !== undefined),
-        onTokenizeSuccess: (primerSettings?.onTokenizeSuccess !== undefined),
-        onResumeSuccess: (primerSettings?.onResumeSuccess !== undefined),
-        onResumePending:  (primerSettings?.onResumePending !== undefined),
-        onCheckoutReceivedAdditionalInfo:  (primerSettings?.onCheckoutReceivedAdditionalInfo !== undefined),
-        onDismiss: (primerSettings?.onDismiss !== undefined),
-        onError: (primerSettings?.onError !== undefined),
+      let implementedRNCallbacks: PrimerImplementedRNCallbacks = {
+        onAvailablePaymentMethodsLoad: false,
+        onTokenizationStart: false,
+        onTokenizationSuccess: (primerSettings?.primerCallbacks?.onTokenizeSuccess !== undefined) || false,
+    
+        onCheckoutResume: (primerSettings?.primerCallbacks?.onResumeSuccess !== undefined) || false,
+        onCheckoutPending: (primerSettings?.primerCallbacks?.onResumePending !== undefined) || false,
+        onCheckoutAdditionalInfo: (primerSettings?.primerCallbacks?.onCheckoutReceivedAdditionalInfo !== undefined) || false,
+    
+        onError: (primerSettings?.primerCallbacks?.onError !== undefined) || false,
+        onCheckoutComplete: (primerSettings?.primerCallbacks?.onCheckoutComplete !== undefined) || false,
+        onBeforeClientSessionUpdate: (primerSettings?.primerCallbacks?.onBeforeClientSessionUpdate !== undefined) || false,
+    
+        onClientSessionUpdate: (primerSettings?.primerCallbacks?.onClientSessionUpdate !== undefined) || false,
+        onBeforePaymentCreate: (primerSettings?.primerCallbacks?.onBeforePaymentCreate !== undefined) || false,
+        onPreparationStart: false,
+    
+        onPaymentMethodShow: false,
+        onDismiss: (primerSettings?.primerCallbacks?.onDismiss !== undefined) || false
       };
 
       await RNPrimer.setImplementedRNCallbacks(implementedRNCallbacks);
 
       if (implementedRNCallbacks.onCheckoutComplete) {
         RNPrimer.addListener('onCheckoutComplete', data => {
-          if (primerSettings && primerSettings.onCheckoutComplete) {
+          if (primerSettings && primerSettings.primerCallbacks?.onCheckoutComplete) {
             const checkoutData: PrimerCheckoutData = data;
-            primerSettings.onCheckoutComplete(checkoutData);
+            primerSettings.primerCallbacks.onCheckoutComplete(checkoutData);
           }
         });
       }
 
       if (implementedRNCallbacks.onBeforePaymentCreate) {
         RNPrimer.addListener('onBeforePaymentCreate', data => {
-          if (primerSettings && primerSettings.onBeforePaymentCreate) {
+          if (primerSettings && primerSettings.primerCallbacks?.onBeforePaymentCreate) {
             const checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData = data;
-            primerSettings.onBeforePaymentCreate(checkoutPaymentMethodData, paymentCreationHandler);
+            primerSettings.primerCallbacks.onBeforePaymentCreate(checkoutPaymentMethodData, paymentCreationHandler);
           }
         });
       }
 
       if (implementedRNCallbacks.onBeforeClientSessionUpdate) {
         RNPrimer.addListener('onBeforeClientSessionUpdate', _ => {
-          if (primerSettings && primerSettings.onBeforeClientSessionUpdate) {
-            primerSettings.onBeforeClientSessionUpdate();
+          if (primerSettings && primerSettings.primerCallbacks?.onBeforeClientSessionUpdate) {
+            primerSettings.primerCallbacks.onBeforeClientSessionUpdate();
           }
         });
       }
 
       if (implementedRNCallbacks.onClientSessionUpdate) {
         RNPrimer.addListener('onClientSessionUpdate', data => {
-          if (primerSettings && primerSettings.onClientSessionUpdate) {
+          if (primerSettings && primerSettings.primerCallbacks?.onClientSessionUpdate) {
             const clientSession: PrimerClientSession = data;
-            primerSettings.onClientSessionUpdate(clientSession);
+            primerSettings.primerCallbacks.onClientSessionUpdate(clientSession);
           }
         });
       }
 
-      if (implementedRNCallbacks.onTokenizeSuccess) {
+      if (implementedRNCallbacks.onTokenizationSuccess) {
         RNPrimer.addListener('onTokenizeSuccess', data => {
-          if (primerSettings && primerSettings.onTokenizeSuccess) {
+          if (primerSettings && primerSettings.primerCallbacks?.onTokenizeSuccess) {
             const paymentMethodTokenData: PrimerPaymentMethodTokenData = data;
-            primerSettings.onTokenizeSuccess(paymentMethodTokenData, tokenizationHandler);
+            primerSettings.primerCallbacks.onTokenizeSuccess(paymentMethodTokenData, tokenizationHandler);
           }
         });
       }
 
-      if (implementedRNCallbacks.onResumeSuccess) {
+      if (implementedRNCallbacks.onCheckoutResume) {
         RNPrimer.addListener('onResumeSuccess', data => {
-          if (primerSettings && primerSettings.onResumeSuccess && data.resumeToken) {
-            primerSettings.onResumeSuccess(data.resumeToken, resumeHandler);
+          if (primerSettings && primerSettings.primerCallbacks?.onResumeSuccess && data.resumeToken) {
+            primerSettings.primerCallbacks.onResumeSuccess(data.resumeToken, resumeHandler);
           }
         });
       }
 
-      if (implementedRNCallbacks.onResumePending) {
+      if (implementedRNCallbacks.onCheckoutPending) {
         RNPrimer.addListener(
           'onResumePending',
           (additionalInfo) => {
-            if (primerSettings && primerSettings.onResumePending) {
+            if (primerSettings && primerSettings.primerCallbacks?.onResumePending) {
               const checkoutAdditionalInfo: PrimerCheckoutAdditionalInfo = additionalInfo;
-              primerSettings.onResumePending(checkoutAdditionalInfo);
+              primerSettings.primerCallbacks.onResumePending(checkoutAdditionalInfo);
             } else {
               // Ignore!
             }
@@ -189,13 +198,13 @@ async function configureListeners(): Promise<void> {
         );
       }
 
-      if (implementedRNCallbacks.onCheckoutReceivedAdditionalInfo) {
+      if (implementedRNCallbacks.onCheckoutAdditionalInfo) {
         RNPrimer.addListener(
           'onCheckoutReceivedAdditionalInfo',
           (additionalInfo) => {
-            if (primerSettings && primerSettings.onCheckoutReceivedAdditionalInfo) {
+            if (primerSettings && primerSettings.primerCallbacks?.onCheckoutReceivedAdditionalInfo) {
               const checkoutAdditionalInfo: PrimerCheckoutAdditionalInfo = additionalInfo;
-              primerSettings.onCheckoutReceivedAdditionalInfo(checkoutAdditionalInfo);
+              primerSettings.primerCallbacks.onCheckoutReceivedAdditionalInfo(checkoutAdditionalInfo);
             } else {
               // Ignore!
             }
@@ -205,25 +214,21 @@ async function configureListeners(): Promise<void> {
 
       if (implementedRNCallbacks.onDismiss) {
         RNPrimer.addListener('onDismiss', _ => {
-          if (primerSettings && primerSettings.onDismiss) {
-            primerSettings.onDismiss();
+          if (primerSettings && primerSettings.primerCallbacks?.onDismiss) {
+            primerSettings.primerCallbacks.onDismiss();
           }
         });
       }
 
       if (implementedRNCallbacks.onError) {
         RNPrimer.addListener('onError', data => {
-          if (data && data.error && data.error.errorId && primerSettings && primerSettings.onError) {
+          if (data && data.error && data.error.errorId && primerSettings && primerSettings.primerCallbacks?.onError) {
             const errorId: string = data.error.errorId;
             const description: string | undefined = data.error.description;
             const recoverySuggestion: string | undefined = data.error.recoverySuggestion;
-            const primerError = new PrimerError(errorId, description || 'Unknown error', recoverySuggestion);
-
-            if (data.checkoutData) {
-              primerSettings.onError(primerError, data.checkoutData, errorHandler);
-            } else {
-              primerSettings.onError(primerError, null, errorHandler);
-            }
+            const diagnosticsId: string | undefined = data.error.diagnosticsId;
+            const primerError = new PrimerError(errorId, description || 'Unknown error', recoverySuggestion, diagnosticsId);
+            primerSettings.primerCallbacks.onError(primerError, data.checkoutData || null, errorHandler);
           }
         });
       }
@@ -278,23 +283,7 @@ export const Primer: IPrimer = {
     });
   },
 
-  async showPaymentMethod(
-    paymentMethodType: string,
-    intent: PrimerSessionIntent,
-    clientToken: string
-  ): Promise<void> {
-    return new Promise(async (resolve, reject) => {
-      try {
-        await configureListeners();
-        await RNPrimer.showPaymentMethod(paymentMethodType, intent, clientToken);
-        resolve();
-      } catch (err) {
-        reject(err);
-      }
-    });
-  },
-
-  dispose(): void {
+  cleanUp(): void {
     RNPrimer.removeAllListeners();
     RNPrimer.dismiss();
   },

package/src/RNPrimer.ts

@@ -1,5 +1,4 @@
 import { NativeEventEmitter, NativeModules } from 'react-native';
-import type { PrimerSessionIntent } from './models/PrimerSessionIntent';
 import type { PrimerSettings } from './models/PrimerSettings';
 
 const { NativePrimer } = NativeModules;
@@ -95,21 +94,6 @@ const RNPrimer = {
     });
   },
 
-  showPaymentMethod: (
-    paymentMethodType: string,
-    intent: PrimerSessionIntent,
-    clientToken: string
-  ): Promise<void> => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        await NativePrimer.showPaymentMethod(paymentMethodType, intent, clientToken);
-        resolve();
-      } catch (err) {
-        reject(err);
-      }
-    });
-  },
-
   dismiss: (): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
@@ -121,10 +105,10 @@ const RNPrimer = {
     });
   },
 
-  dispose: (): Promise<void> => {
+  cleanUp: (): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        await NativePrimer.dispose();
+        await NativePrimer.cleanUp();
         resolve();
       } catch (err) {
         reject(err);

package/src/index.tsx

@@ -5,54 +5,68 @@ export {
     PrimerSettings
 } from './models/PrimerSettings';
 export {
-    PrimerSessionIntent
+    PrimerInputElementType as InputElementType
+} from './models/PrimerInputElementType';
+export {
+    PrimerSessionIntent as SessionIntent
 } from './models/PrimerSessionIntent';
 export {
-    PrimerPaymentCreationHandler,
-    PrimerTokenizationHandler,
-    PrimerResumeHandler,
-    PrimerErrorHandler,
-} from './models/PrimerInterfaces';
+    PrimerPaymentCreationHandler as PaymentCreationHandler,
+    PrimerTokenizationHandler as TokenizationHandler,
+    PrimerResumeHandler as ResumeHandler,
+    PrimerErrorHandler as ErrorHandler,
+} from './models/PrimerHandlers';
 export { PrimerPaymentMethodTokenData } from './models/PrimerPaymentMethodTokenData';
 export {
-    PrimerClientSession,
-    PrimerOrder,
-    PrimerLineItem,
-    PrimerCustomer,
-    PrimerAddress,
+    PrimerClientSession as ClientSession,
+    PrimerOrder as Order,
+    PrimerLineItem as LineItem,
+    PrimerCustomer as Customer,
+    PrimerAddress as Address,
 } from './models/PrimerClientSession';
 export {
-    PrimerRawData,
-    PrimerRawCardData,
-    PrimerRawPhoneNumberData,
-    PrimerRawCardRedirectData,
-    PrimerBancontactCardRedirectData,
-    PrimerRawRetailerData
+    PrimerRawData as RawData,
+    PrimerCardData as CardData,
+    PrimerBancontactCardData as BancontactCardData,
+    PrimerPhoneNumberData as PhoneNumberData,
+    PrimerRetailerData as RetailerData
 } from './models/PrimerRawData';
 export {
-    PrimerCheckoutAdditionalInfo,
-    MultibancoCheckoutAdditionalInfo,
-    PrimerCheckoutVoucherAdditionalInfo,
-    XenditCheckoutVoucherAdditionalInfo,
-    PrimerCheckoutQRCodeInfo,
-    PromptPayCheckoutAdditionalInfo
+    PrimerCheckoutAdditionalInfo as CheckoutAdditionalInfo,
+    MultibancoCheckoutAdditionalInfo
 } from './models/PrimerCheckoutAdditionalInfo';
 export {
     RetailOutletsRetail
 } from './models/RetailOutletsRetail';
 export {
-    PrimerCheckoutData,
-    PrimerCheckoutDataPayment,
+    PrimerCheckoutData as CheckoutData,
+    PrimerCheckoutDataPayment as CheckoutDataPayment,
 } from './models/PrimerCheckoutData';
 export {
-    PrimerCheckoutPaymentMethodData
+    PrimerCheckoutPaymentMethodData as CheckoutPaymentMethodData
 } from './models/PrimerCheckoutPaymentMethodData';
 export {
     PrimerError
 } from './models/PrimerError';
+export type {
+    IPrimerAsset as Asset
+} from './models/PrimerAsset';
 export {
     PrimerHeadlessUniversalCheckout as HeadlessUniversalCheckout
-} from './headless_checkout/PrimerHeadlessUniversalCheckout';
+} from './HeadlessUniversalCheckout/PrimerHeadlessUniversalCheckout';
+export type {
+    IPrimerHeadlessUniversalCheckoutPaymentMethod as PaymentMethod
+} from './models/PrimerHeadlessUniversalCheckoutPaymentMethod';
+
+import PrimerHeadlessUniversalCheckoutAssetsManager from './HeadlessUniversalCheckout/Managers/AssetsManager';
+export {
+    PrimerHeadlessUniversalCheckoutAssetsManager as AssetsManager
+}
+import PrimerHeadlessUniversalCheckoutPaymentMethodNativeUIManager from './HeadlessUniversalCheckout/Managers/PaymentMethodManagers/NativeUIManager';
+export {
+    PrimerHeadlessUniversalCheckoutPaymentMethodNativeUIManager as NativeUIManager
+}
+import PrimerHeadlessUniversalCheckoutRawDataManager from './HeadlessUniversalCheckout/Managers/PaymentMethodManagers/RawDataManager';
 export {
-    PrimerHeadlessUniversalCheckoutRawDataManager as HeadlessUniversalCheckoutRawDataManager
-} from './headless_checkout/PrimerHeadlessUniversalCheckoutRawDataManager';
+    PrimerHeadlessUniversalCheckoutRawDataManager as RawDataManager
+}

package/src/models/PrimerAsset.ts

@@ -0,0 +1,13 @@
+export interface IPrimerAsset {
+    paymentMethodType: string;
+    paymentMethodLogo: {
+        colored?: string;
+        dark?: string;
+        light?: string;
+    }
+    paymentMethodBackgroundColor: {
+        colored?: string;
+        dark?: string;
+        light?: string;
+    }
+}

package/src/models/PrimerError.ts

@@ -10,11 +10,13 @@ export class PrimerError extends Error {
   errorId: string;
   description: string;
   recoverySuggestion?: string;
+  diagnosticsId?: string;
 
-  constructor(errorId: string, description: string, recoverySuggestion: string | undefined) {
+  constructor(errorId: string, description: string, recoverySuggestion: string | undefined, diagnosticsId: string | undefined) {
       super(description);
       this.errorId = errorId;
       this.description = description;
       this.recoverySuggestion = recoverySuggestion;
+      this.diagnosticsId = diagnosticsId;
   }
 }

package/src/models/PrimerHandlers.ts

@@ -0,0 +1,25 @@
+export interface PrimerPaymentCreationHandler {
+    abortPaymentCreation(errorMessage: string | null): void;
+    continuePaymentCreation(): void;
+  }
+  
+  export interface PrimerTokenizationHandler {
+    handleSuccess(): void;
+    handleFailure(errorMessage: string | null): void;
+    continueWithNewClientToken(newClientToken: string): void;
+  }
+  
+  export interface PrimerResumeHandler {
+    handleSuccess(): void;
+    handleFailure(errorMessage: string | null): void;
+    continueWithNewClientToken(newClientToken: string): void;
+  }
+  
+  export interface PrimerHeadlessUniversalCheckoutResumeHandler {
+    continueWithNewClientToken(newClientToken: string): void;
+    complete(): void;
+  }
+  
+  export interface PrimerErrorHandler {
+    showErrorMessage(errorMessage: string | null): void;
+  }

package/src/models/PrimerHeadlessUniversalCheckoutPaymentMethod.ts

@@ -0,0 +1,5 @@
+export interface IPrimerHeadlessUniversalCheckoutPaymentMethod {
+    paymentMethodType: string;
+    paymentMethodManagerCategories: ("NATIVE_UI" | "RAW_DATA" | "CARD_COMPONENTS")[];
+    supportedPrimerSessionIntents: ("CHECKOUT" | "VAULT")[];
+}

package/src/models/PrimerImplementedRNCallbacks.ts

@@ -0,0 +1,20 @@
+export interface PrimerImplementedRNCallbacks {
+    onAvailablePaymentMethodsLoad: boolean;
+    onTokenizationStart: boolean;
+    onTokenizationSuccess: boolean;
+
+    onCheckoutResume: boolean;
+    onCheckoutPending: boolean;
+    onCheckoutAdditionalInfo: boolean;
+
+    onError: boolean;
+    onCheckoutComplete: boolean;
+    onBeforeClientSessionUpdate: boolean;
+
+    onClientSessionUpdate: boolean;
+    onBeforePaymentCreate: boolean;
+    onPreparationStart: boolean;
+
+    onPaymentMethodShow: boolean;
+    onDismiss: boolean;
+}

package/src/models/PrimerInputElementType.ts

@@ -0,0 +1,11 @@
+export enum PrimerInputElementType {
+    CARD_NUMBER = "CARD_NUMBER",
+    EXPIRY_DATE = "EXPIRY_DATE",
+    CVV = "CVV",
+    CARDHOLDER_NAME = "CARDHOLDER_NAME",
+    OTP = "OTP",
+    POSTAL_CODE = "POSTAL_CODE",
+    PHONE_NUMBER = "PHONE_NUMBER",
+    RETAILER = "RETAILER",
+    UNKNOWN = "UNKNOWN"
+}

package/src/models/PrimerInterfaces.ts

@@ -1,36 +1,9 @@
-import type { PrimerSessionIntent } from "./PrimerSessionIntent";
 import type { PrimerSettings } from "./PrimerSettings";
 
 export interface IPrimer {
   configure(settings: PrimerSettings): Promise<void>;
   showUniversalCheckout(clientToken: string): Promise<void>;
   showVaultManager(clientToken: string): Promise<void>;
-  showPaymentMethod(
-    paymentMethodType: string,
-    intent: PrimerSessionIntent,
-    clientToken: string
-  ): Promise<void>
   dismiss(): void;
-  dispose(): void;
-}
-
-export interface PrimerPaymentCreationHandler {
-  abortPaymentCreation(errorMessage: string | null): void;
-  continuePaymentCreation(): void;
-}
-
-export interface PrimerTokenizationHandler {
-  handleSuccess(): void;
-  handleFailure(errorMessage: string | null): void;
-  continueWithNewClientToken(newClientToken: string): void;
-}
-
-export interface PrimerResumeHandler {
-  handleSuccess(): void;
-  handleFailure(errorMessage: string | null): void;
-  continueWithNewClientToken(newClientToken: string): void;
-}
-
-export interface PrimerErrorHandler {
-  showErrorMessage(errorMessage: string | null): void;
+  cleanUp(): void;
 }

package/src/models/PrimerPaymentMethodManagerCategory.ts

@@ -0,0 +1,5 @@
+export enum PrimerPaymentMethodManagerCategory {
+    CARD_COMPONENTS = "CARD_COMPONENTS",
+    NATIVE_UI = 'NATIVE_UI',
+    RAW_DATA = 'RAW_DATA'
+}

package/src/models/PrimerRawData.ts

@@ -1,26 +1,22 @@
 export interface PrimerRawData {}
 
-export interface PrimerRawCardData extends PrimerRawData {
+export interface PrimerCardData extends PrimerRawData {
     cardNumber: string;
-    expiryMonth: string;
-    expiryYear: string;
+    expiryDate: string;
     cvv: string;
     cardholderName?: string;
 }
 
-export interface PrimerRawPhoneNumberData extends PrimerRawData {
+export interface PrimerPhoneNumberData extends PrimerRawData {
     phoneNumber: string;
 }
 
-export interface PrimerRawCardRedirectData extends PrimerRawData {}
-
-export interface PrimerBancontactCardRedirectData extends PrimerRawCardRedirectData {
+export interface PrimerBancontactCardData extends PrimerRawData {
     cardNumber: string;
-    expiryMonth: string;
-    expiryYear: string;
+    expiryDate: string;
     cardholderName: string;
 }
 
-export interface PrimerRawRetailerData extends PrimerRawData {
+export interface PrimerRetailerData extends PrimerRawData {
     id: string;
 }

package/src/models/PrimerSettings.ts

@@ -1,9 +1,4 @@
-import type {
-  PrimerErrorHandler,
-  PrimerPaymentCreationHandler,
-  PrimerResumeHandler,
-  PrimerTokenizationHandler
-} from "./PrimerInterfaces";
+
 import type { PrimerCheckoutData } from "./PrimerCheckoutData";
 import type { PrimerCheckoutAdditionalInfo } from "./PrimerCheckoutAdditionalInfo";
 import type { PrimerCheckoutPaymentMethodData } from "./PrimerCheckoutPaymentMethodData";
@@ -11,6 +6,13 @@ import type { PrimerClientSession } from "./PrimerClientSession";
 import type { PrimerPaymentMethodTokenData } from "./PrimerPaymentMethodTokenData";
 import type { PrimerError } from "./PrimerError";
 import type { IPrimerTheme } from "./PrimerTheme";
+import type { 
+  PrimerPaymentCreationHandler,
+  PrimerTokenizationHandler,
+  PrimerResumeHandler,
+  PrimerErrorHandler,
+  PrimerHeadlessUniversalCheckoutResumeHandler
+} from "./PrimerHandlers";
 
 export type PrimerSettings = IPrimerSettings;
 
@@ -21,26 +23,38 @@ interface IPrimerSettings {
   uiOptions?: IPrimerUIOptions;
   debugOptions?: IPrimerDebugOptions;
 
-  // Common
-  onBeforeClientSessionUpdate?: () => void;
-  onClientSessionUpdate?: (clientSession: PrimerClientSession) => void;
-  onBeforePaymentCreate?: (checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData, handler: PrimerPaymentCreationHandler) => void;
-  onCheckoutComplete?: (checkoutData: PrimerCheckoutData) => void;
-  onTokenizeSuccess?: (paymentMethodTokenData: PrimerPaymentMethodTokenData, handler: PrimerTokenizationHandler) => void;
-  onResumeSuccess?: (resumeToken: string, handler: PrimerResumeHandler) => void;
-  onResumePending?: (additionalInfo: PrimerCheckoutAdditionalInfo) => void;
-  onCheckoutReceivedAdditionalInfo?: (additionalInfo: PrimerCheckoutAdditionalInfo) => void;
-  // PrimerErrorHandler will be undefined on the HUC flow.
-  onError?: (error: PrimerError, checkoutData: PrimerCheckoutData | null, handler: PrimerErrorHandler | undefined) => void;
-
-  // Only on main SDK
-  onDismiss?: () => void;
-
-  // Only on HUC
-  onPrepareStart?: (paymentMethod: string) => void;
-  onTokenizeStart?: (paymentMethod: string) => void;
-  onPaymentMethodShow?: (paymentMethod: string) => void;
-  onAvailablePaymentMethodsLoad?: (paymentMethods: string[]) => void;
+  primerCallbacks?: {
+    onBeforeClientSessionUpdate?: () => void;
+    onClientSessionUpdate?: (clientSession: PrimerClientSession) => void;
+    onBeforePaymentCreate?: (checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData, handler: PrimerPaymentCreationHandler) => void;
+    onCheckoutComplete?: (checkoutData: PrimerCheckoutData) => void;
+    onTokenizeSuccess?: (paymentMethodTokenData: PrimerPaymentMethodTokenData, handler: PrimerTokenizationHandler) => void;
+    onResumeSuccess?: (resumeToken: string, handler: PrimerResumeHandler) => void;
+    onResumePending?: (additionalInfo: PrimerCheckoutAdditionalInfo) => void;
+    onCheckoutReceivedAdditionalInfo?: (additionalInfo: PrimerCheckoutAdditionalInfo) => void;
+    onError?: (error: PrimerError, checkoutData: PrimerCheckoutData | null, handler: PrimerErrorHandler | undefined) => void;
+    onDismiss?: () => void;
+  };
+
+  headlessUniversalCheckoutCallbacks?: {
+    onAvailablePaymentMethodsLoad?: (availablePaymentMethods: any[]) => void;
+    onTokenizationStart?: (paymentMethodType: string) => void;
+    onTokenizationSuccess?: (paymentMethodTokenData: PrimerPaymentMethodTokenData, handler: PrimerHeadlessUniversalCheckoutResumeHandler) => void;
+
+    onCheckoutResume?: (resumeToken: string, handler: PrimerHeadlessUniversalCheckoutResumeHandler) => void;
+    onCheckoutPending?: (additionalInfo: PrimerCheckoutAdditionalInfo) => void;
+    onCheckoutAdditionalInfo?: (additionalInfo: PrimerCheckoutAdditionalInfo) => void;
+
+    onError?: (error: PrimerError, checkoutData: PrimerCheckoutData | null) => void;
+    onCheckoutComplete?: (checkoutData: PrimerCheckoutData) => void;
+    onBeforeClientSessionUpdate?: () => void;
+
+    onClientSessionUpdate?: (clientSession: PrimerClientSession) => void;
+    onBeforePaymentCreate?: (checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData, handler: PrimerPaymentCreationHandler) => void;
+    onPreparationStart?: (paymentMethodType: string) => void;
+
+    onPaymentMethodShow?: (paymentMethodType: string) => void;
+  }
 }
 
 //----------------------------------------

package/android/src/main/java/com/primerioreactnative/huc/datamodels/manager/raw/cardRedirect/PrimerRNPRawCardRedirectData.kt

@@ -1,20 +0,0 @@
-package com.primerioreactnative.huc.datamodels.manager.raw.cardRedirect
-
-import io.primer.android.components.domain.core.models.bancontact.PrimerRawBancontactCardData
-import kotlinx.serialization.Serializable
-
-@Serializable
-internal data class PrimerRNRawBancontactCardData(
-  val cardNumber: String,
-  val expiryMonth: String,
-  val expiryYear: String,
-  val cardholderName: String
-) {
-  fun toPrimerRawBancontactCardData() =
-    PrimerRawBancontactCardData(
-      cardNumber,
-      expiryMonth,
-      expiryYear,
-      cardholderName
-    )
-}

package/android/src/main/java/com/primerioreactnative/huc/datamodels/manager/raw/phoneNumber/PrimerRNRawPhoneNumberData.kt

@@ -1,14 +0,0 @@
-package com.primerioreactnative.huc.datamodels.manager.raw.phoneNumber
-
-import io.primer.android.components.domain.core.models.phoneNumber.PrimerRawPhoneNumberData
-import kotlinx.serialization.Serializable
-
-@Serializable
-internal data class PrimerRNRawPhoneNumberData(
-  val phoneNumber: String? = null,
-) {
-  fun toPrimerRawPhoneNumberData() =
-    PrimerRawPhoneNumberData(
-      phoneNumber.orEmpty()
-    )
-}

package/android/src/main/java/com/primerioreactnative/huc/datamodels/manager/raw/retailOutlets/PrimerRNRawRetailOutletData.kt

@@ -1,12 +0,0 @@
-package com.primerioreactnative.huc.datamodels.manager.raw.retailOutlets
-
-import io.primer.android.components.domain.core.models.retailOutlet.PrimerRawRetailerData
-import kotlinx.serialization.Serializable
-
-@Serializable
-internal data class PrimerRNRawRetailOutletData(
-  val id: String
-) {
-
-  fun toPrimerRawRetailOutletData() = PrimerRawRetailerData(id)
-}