@primer-io/react-native 2.16.7 → 2.17.0-rc.10

package/src/{headless_checkout → HeadlessUniversalCheckout}/RNPrimerHeadlessUniversalCheckout.ts

@@ -1,38 +1,47 @@
 import { NativeEventEmitter, NativeModules } from 'react-native';
+import type { PrimerSettings } from '../models/PrimerSettings';
 
 const { PrimerHeadlessUniversalCheckout } = NativeModules;
 
 const eventEmitter = new NativeEventEmitter(PrimerHeadlessUniversalCheckout);
 
 type EventType =
-  | 'onHUCTokenizeStart'
-  | 'onHUCPrepareStart'
-  | 'onHUCAvailablePaymentMethodsLoaded'
-  | 'onHUCPaymentMethodShow'
-  | 'onTokenizeSuccess'
-  | 'onResumeSuccess'
-  | 'onResumePending'
-  | 'onCheckoutReceivedAdditionalInfo'
-  | 'onBeforePaymentCreate'
+  | 'onAvailablePaymentMethodsLoad'
+  | 'onTokenizationStart'
+  | 'onTokenizationSuccess'
+
+  | 'onCheckoutResume'
+  | 'onCheckoutPending'
+  | 'onCheckoutAdditionalInfo'
+
+  | 'onError'
+  | 'onCheckoutComplete'
   | 'onBeforeClientSessionUpdate'
+
   | 'onClientSessionUpdate'
-  | 'onCheckoutComplete'
-  | 'onError';
+  | 'onBeforePaymentCreate'
+  | 'onPreparationStart'
+
+  | 'onPaymentMethodShow';
 
 const eventTypes: EventType[] = [
-  'onHUCTokenizeStart',
-  'onHUCPrepareStart',
-  'onHUCAvailablePaymentMethodsLoaded',
-  'onHUCPaymentMethodShow',
-  'onTokenizeSuccess',
-  'onResumeSuccess',
-  'onResumePending',
-  'onCheckoutReceivedAdditionalInfo',
-  'onBeforePaymentCreate',
+  'onAvailablePaymentMethodsLoad',
+  'onTokenizationStart',
+  'onTokenizationSuccess',
+
+  'onCheckoutResume',
+  'onCheckoutPending',
+  'onCheckoutAdditionalInfo',
+
+  'onError',
+  'onCheckoutComplete',
   'onBeforeClientSessionUpdate',
+
   'onClientSessionUpdate',
-  'onCheckoutComplete',
-  'onError'
+  'onBeforePaymentCreate',
+  'onPreparationStart',
+
+  'onPaymentMethodShow'
 ];
 
 const RNPrimerHeadlessUniversalCheckout = {
@@ -58,75 +67,9 @@ const RNPrimerHeadlessUniversalCheckout = {
   ///////////////////////////////////////////
   // Native API
   ///////////////////////////////////////////
-  getAssetForPaymentMethodType: (
-    paymentMethodType: string,
-    assetType: 'logo' | 'icon'
-  ): Promise<string> => {
-    return new Promise((resolve, reject) => {
-      try {
-        PrimerHeadlessUniversalCheckout.getAssetForPaymentMethodType(
-          paymentMethodType,
-          assetType,
-          (err: Error) => {
-            reject(err);
-          },
-          (url: string) => {
-            resolve(url);
-          }
-        );
-      } catch (e) {
-        reject(e);
-      }
-    });
-  },
-
-  getAssetForCardNetwork: (
-    cardNetwork: string,
-    assetType: 'logo' | 'icon'
-  ): Promise<string> => {
-    return new Promise((resolve, reject) => {
-      try {
-        PrimerHeadlessUniversalCheckout.getAssetForCardNetwork(
-          cardNetwork,
-          assetType,
-          (err: Error) => {
-            reject(err);
-          },
-          (url: string) => {
-            resolve(url);
-          }
-        );
-      } catch (e) {
-        reject(e);
-      }
-    });
-  },
 
-  startWithClientToken(clientToken: string, settings: any): Promise<any> {
-    return new Promise((resolve, reject) => {
-      PrimerHeadlessUniversalCheckout.startWithClientToken(
-        clientToken,
-        JSON.stringify(settings),
-        (err: Error) => {
-          console.error(err);
-          reject(err);
-        },
-        (paymentMethodTypes: string[]) => {
-          resolve({ paymentMethodTypes });
-        }
-      );
-    });
-  },
-
-  showPaymentMethod: (paymentMethodType: string): Promise<void> => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        await PrimerHeadlessUniversalCheckout.showPaymentMethod(paymentMethodType);
-        resolve();
-      } catch (err) {
-        reject(err);
-      }
-    });
+  startWithClientToken(clientToken: string, settings: PrimerSettings): Promise<any> {
+    return PrimerHeadlessUniversalCheckout.startWithClientToken(clientToken, JSON.stringify(settings));
   },
 
   ///////////////////////////////////////////
@@ -146,28 +89,6 @@ const RNPrimerHeadlessUniversalCheckout = {
     });
   },
 
-  handleTokenizationSuccess: (): Promise<void> => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        await PrimerHeadlessUniversalCheckout.handleTokenizationSuccess();
-        resolve();
-      } catch (err) {
-        reject(err);
-      }
-    });
-  },
-
-  handleTokenizationFailure: (errorMessage: string | null): Promise<void> => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        await PrimerHeadlessUniversalCheckout.handleTokenizationFailure(errorMessage || "");
-        resolve();
-      } catch (err) {
-        reject(err);
-      }
-    });
-  },
-
   // Resume Handlers
 
   handleResumeWithNewClientToken: (newClientToken: string): Promise<void> => {
@@ -181,21 +102,10 @@ const RNPrimerHeadlessUniversalCheckout = {
     });
   },
 
-  handleResumeSuccess: (): Promise<void> => {
+  handleCompleteFlow: (): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        await PrimerHeadlessUniversalCheckout.handleResumeSuccess();
-        resolve();
-      } catch (err) {
-        reject(err);
-      }
-    });
-  },
-
-  handleResumeFailure: (errorMessage: string | null): Promise<void> => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        await PrimerHeadlessUniversalCheckout.handleTokenizationFailure(errorMessage || "");
+        await PrimerHeadlessUniversalCheckout.handleCompleteFlow();
         resolve();
       } catch (err) {
         reject(err);
@@ -240,11 +150,10 @@ const RNPrimerHeadlessUniversalCheckout = {
     });
   },
 
-
-  disposePrimerHeadlessUniversalCheckout: (): Promise<void> => {
+  cleanUp: (): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        await PrimerHeadlessUniversalCheckout.disposePrimerHeadlessUniversalCheckout();
+        await PrimerHeadlessUniversalCheckout.cleanUp();
         resolve();
       } catch (err) {
         reject(err);

package/src/HeadlessUniversalCheckout/types.ts

@@ -0,0 +1,32 @@
+// import type { PrimerCheckoutData } from '../models/PrimerCheckoutData';
+// import type { PrimerCheckoutPaymentMethodData } from '../models/PrimerCheckoutPaymentMethodData';
+// import type { 
+//   PrimerTokenizationHandler, 
+//   PrimerResumeHandler, 
+//   PrimerPaymentCreationHandler, 
+//   PrimerErrorHandler
+// } from '../models/PrimerInterfaces';
+// import type { PrimerClientSession } from '../models/PrimerClientSession';
+// import type { PrimerPaymentMethodTokenData } from '../models/PrimerPaymentMethodTokenData'; 
+// import type { PrimerError } from '../models/PrimerError';
+
+// export interface PrimerHeadlessUniversalCheckoutStartResponse {
+//   paymentMethodTypes: string[];
+// }
+
+// export interface PrimerHeadlessUniversalCheckoutCallbacks {
+//   // 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;
+//   onError?: (error: PrimerError, checkoutData: PrimerCheckoutData | null, handler: PrimerErrorHandler | undefined) => void;
+
+//   // Only on HUC
+//   onPrepareStart?: (paymentMethodType: string) => void;
+//   onTokenizeStart?: (paymentMethodType: string) => void;
+//   onPaymentMethodShow?: (paymentMethodType: string) => void;
+//   onAvailablePaymentMethodTypesLoad?: (paymentMethodTypes: string[]) => void;
+// }

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,17 +109,25 @@ 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?.onTokenizeSuccess !== undefined) || false,
+    
+        onCheckoutResume: (primerSettings?.onResumeSuccess !== undefined) || false,
+        onCheckoutPending: (primerSettings?.onResumePending !== undefined) || false,
+        onCheckoutAdditionalInfo: (primerSettings?.onCheckoutReceivedAdditionalInfo !== undefined) || false,
+    
+        onError: (primerSettings?.onError !== undefined) || false,
+        onCheckoutComplete: (primerSettings?.onCheckoutComplete !== undefined) || false,
+        onBeforeClientSessionUpdate: (primerSettings?.onBeforeClientSessionUpdate !== undefined) || false,
+    
+        onClientSessionUpdate: (primerSettings?.onClientSessionUpdate !== undefined) || false,
+        onBeforePaymentCreate: (primerSettings?.onBeforePaymentCreate !== undefined) || false,
+        onPreparationStart: false,
+    
+        onPaymentMethodShow: false,
+        onDismiss: (primerSettings?.onDismiss !== undefined) || false
       };
 
       await RNPrimer.setImplementedRNCallbacks(implementedRNCallbacks);
@@ -158,7 +167,7 @@ async function configureListeners(): Promise<void> {
         });
       }
 
-      if (implementedRNCallbacks.onTokenizeSuccess) {
+      if (implementedRNCallbacks.onTokenizationSuccess) {
         RNPrimer.addListener('onTokenizeSuccess', data => {
           if (primerSettings && primerSettings.onTokenizeSuccess) {
             const paymentMethodTokenData: PrimerPaymentMethodTokenData = data;
@@ -167,7 +176,7 @@ async function configureListeners(): Promise<void> {
         });
       }
 
-      if (implementedRNCallbacks.onResumeSuccess) {
+      if (implementedRNCallbacks.onCheckoutResume) {
         RNPrimer.addListener('onResumeSuccess', data => {
           if (primerSettings && primerSettings.onResumeSuccess && data.resumeToken) {
             primerSettings.onResumeSuccess(data.resumeToken, resumeHandler);
@@ -175,7 +184,7 @@ async function configureListeners(): Promise<void> {
         });
       }
 
-      if (implementedRNCallbacks.onResumePending) {
+      if (implementedRNCallbacks.onCheckoutPending) {
         RNPrimer.addListener(
           'onResumePending',
           (additionalInfo) => {
@@ -189,7 +198,7 @@ async function configureListeners(): Promise<void> {
         );
       }
 
-      if (implementedRNCallbacks.onCheckoutReceivedAdditionalInfo) {
+      if (implementedRNCallbacks.onCheckoutAdditionalInfo) {
         RNPrimer.addListener(
           'onCheckoutReceivedAdditionalInfo',
           (additionalInfo) => {
@@ -217,13 +226,9 @@ async function configureListeners(): Promise<void> {
             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.onError(primerError, data.checkoutData || null, errorHandler);
           }
         });
       }
@@ -278,15 +283,11 @@ export const Primer: IPrimer = {
     });
   },
 
-  async showPaymentMethod(
-    paymentMethodType: string,
-    intent: PrimerSessionIntent,
-    clientToken: string
-  ): Promise<void> {
+  async showPaymentMethod(paymentMethod: string, intent: string, clientToken: string): Promise<void> {
     return new Promise(async (resolve, reject) => {
       try {
         await configureListeners();
-        await RNPrimer.showPaymentMethod(paymentMethodType, intent, clientToken);
+        await RNPrimer.showPaymentMethod(paymentMethod, intent, clientToken);
         resolve();
       } catch (err) {
         reject(err);
@@ -294,7 +295,7 @@ export const Primer: IPrimer = {
     });
   },
 
-  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,14 +94,10 @@ const RNPrimer = {
     });
   },
 
-  showPaymentMethod: (
-    paymentMethodType: string,
-    intent: PrimerSessionIntent,
-    clientToken: string
-  ): Promise<void> => {
+  showPaymentMethod: (paymentMethod: string, intent: string, clientToken: string): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        await NativePrimer.showPaymentMethod(paymentMethodType, intent, clientToken);
+        await NativePrimer.showPaymentMethod(paymentMethod, intent, clientToken);
         resolve();
       } catch (err) {
         reject(err);
@@ -121,10 +116,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,14 @@
+export interface IPrimerAsset {
+    paymentMethodType: string;
+    paymentMethodName: 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,10 @@
-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>
+  showPaymentMethod(paymentMethod: string, intent: string, 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'
+}