@primer-io/react-native 2.0.0 → 2.1.1

package/src/headless_checkout/PrimerHeadlessUniversalCheckout.ts

@@ -0,0 +1,327 @@
+import RNPrimerHeadlessUniversalCheckout from './RNPrimerHeadlessUniversalCheckout';
+import type { PrimerCheckoutData } from '../models/PrimerCheckoutData';
+import type { PrimerCheckoutPaymentMethodData } from '../models/PrimerCheckoutPaymentMethodData';
+import type { PrimerTokenizationHandler, PrimerResumeHandler, PrimerPaymentCreationHandler } from '../models/PrimerInterfaces';
+import type { PrimerHeadlessUniversalCheckoutStartResponse } from './types';
+import type { PrimerSettings } from '../models/PrimerSettings';
+import type { PrimerClientSession } from '../models/PrimerClientSession';
+import { PrimerError } from '../models/PrimerError';
+import type { PrimerPaymentMethodTokenData } from '../models/PrimerPaymentMethodTokenData';
+
+///////////////////////////////////////////
+// DECISION HANDLERS
+///////////////////////////////////////////
+
+// Tokenization Handler
+
+const tokenizationHandler: PrimerTokenizationHandler = {
+  handleFailure: async (errorMessage: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleTokenizationFailure(errorMessage);
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  handleSuccess: async () => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleTokenizationSuccess();
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  continueWithNewClientToken: async (newClientToken: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleTokenizationNewClientToken(newClientToken);
+    } catch (err) {
+      console.error(err);
+    }
+  }
+}
+
+// Resume Handler
+
+const resumeHandler: PrimerResumeHandler = {
+  handleFailure: async (errorMessage: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleResumeFailure(errorMessage);
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  handleSuccess: async () => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleResumeSuccess();
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  continueWithNewClientToken: async (newClientToken: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleResumeWithNewClientToken(newClientToken);
+    } catch (err) {
+      console.error(err);
+    }
+  }
+}
+
+// Payment Creation Handler
+
+const paymentCreationHandler: PrimerPaymentCreationHandler = {
+  abortPaymentCreation: async (errorMessage: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handlePaymentCreationAbort(errorMessage);
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  continuePaymentCreation: async () => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handlePaymentCreationContinue();
+    } catch (err) {
+      console.error(err);
+    }
+  }
+}
+
+let primerSettings: PrimerSettings | undefined = undefined;
+
+async function configureListeners(): Promise<void> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.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),
+        onDismiss: false,
+        onError: (primerSettings?.onError !== undefined),
+        onHUCAvailablePaymentMethodsLoaded: (primerSettings?.onAvailablePaymentMethodsLoad !== undefined),
+        onHUCPrepareStart: (primerSettings?.onPrepareStart !== undefined),
+        onHUCTokenizeStart: (primerSettings?.onTokenizeStart !== undefined),
+        onHUCPaymentMethodShow: (primerSettings?.onPaymentMethodShow !== undefined),
+      };
+
+      await RNPrimerHeadlessUniversalCheckout.setImplementedRNCallbacks(implementedRNCallbacks);
+
+      if (implementedRNCallbacks.onCheckoutComplete) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onCheckoutComplete',
+          (data) => {
+            console.log('onCheckoutComplete');
+            if (primerSettings && primerSettings.onCheckoutComplete) {
+              const checkoutData: PrimerCheckoutData = data;
+              primerSettings.onCheckoutComplete(checkoutData);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onHUCPrepareStart) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onHUCPrepareStart',
+          (data) => {
+            console.log('onHUCPrepareStart');
+            if (primerSettings && primerSettings.onPrepareStart) {
+              primerSettings.onPrepareStart(data.paymentMethodType || 'not implemented');
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onHUCTokenizeStart) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onHUCTokenizeStart',
+          (data) => {
+            console.log('onHUCTokenizeStart');
+            if (primerSettings && primerSettings.onTokenizeStart) {
+              primerSettings.onTokenizeStart(data.paymentMethodType || 'not implemented');
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onHUCPaymentMethodShow) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onHUCPaymentMethodShow',
+          (data) => {
+            console.log('onHUCPaymentMethodShow');
+            if (primerSettings && primerSettings.onPaymentMethodShow) {
+              primerSettings.onPaymentMethodShow(data.paymentMethodType || 'not implemented');
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onHUCAvailablePaymentMethodsLoaded) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onHUCAvailablePaymentMethodsLoaded',
+          (data) => {
+            console.log('onHUCAvailablePaymentMethodsLoaded');
+            if (primerSettings && primerSettings.onAvailablePaymentMethodsLoad) {
+              if (data && data.paymentMethodTypes) {
+                const paymentMethodTypes: string[] = data.paymentMethodTypes;
+                const availablePaymentMethodTypes = paymentMethodTypes.filter(pmt => pmt !== 'PAYMENT_CARD');
+                primerSettings.onAvailablePaymentMethodsLoad(availablePaymentMethodTypes || ['not implemented']);
+              } else {
+                primerSettings.onAvailablePaymentMethodsLoad(['not implemented']);
+              }
+              
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onBeforePaymentCreate) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onBeforePaymentCreate', data => {
+          if (primerSettings && primerSettings.onBeforePaymentCreate) {
+            const checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData = data;
+            primerSettings.onBeforePaymentCreate(checkoutPaymentMethodData, paymentCreationHandler);
+          }
+        });
+      }
+
+      if (implementedRNCallbacks.onBeforeClientSessionUpdate) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onBeforeClientSessionUpdate', _ => {
+          if (primerSettings && primerSettings.onBeforeClientSessionUpdate) {
+            primerSettings.onBeforeClientSessionUpdate();
+          }
+        });
+      }
+
+      if (implementedRNCallbacks.onClientSessionUpdate) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onClientSessionUpdate', data => {
+          if (primerSettings && primerSettings.onClientSessionUpdate) {
+            const clientSession: PrimerClientSession = data;
+            primerSettings.onClientSessionUpdate(clientSession);
+          }
+        });
+      }
+
+      if (implementedRNCallbacks.onTokenizeSuccess) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onTokenizeSuccess', data => {
+          if (primerSettings && primerSettings.onTokenizeSuccess) {
+            const paymentMethodTokenData: PrimerPaymentMethodTokenData = data;
+            primerSettings.onTokenizeSuccess(paymentMethodTokenData, tokenizationHandler);
+          }
+        });
+      }
+
+      if (implementedRNCallbacks.onResumeSuccess) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onResumeSuccess', data => {
+          if (primerSettings && primerSettings.onResumeSuccess && data.resumeToken) {
+            primerSettings.onResumeSuccess(data.resumeToken, resumeHandler);
+          }
+        });
+      }
+
+      if (implementedRNCallbacks.onError) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onError', data => {
+          if (data && data.error && data.error.errorId && primerSettings && primerSettings.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, undefined);
+            } else {
+              primerSettings.onError(primerError, null, undefined);
+            }
+          }
+        });
+      }
+
+      resolve();
+
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+class PrimerHeadlessUniversalCheckoutClass {
+
+  ///////////////////////////////////////////
+  // Init
+  ///////////////////////////////////////////
+  constructor() {
+
+  }
+
+  ///////////////////////////////////////////
+  // API
+  ///////////////////////////////////////////
+  startWithClientToken(
+    clientToken: string,
+    settings: PrimerSettings
+  ): Promise<string[]> {
+    primerSettings = settings;
+
+    return new Promise(async (resolve, reject) => {
+      try {
+        await configureListeners();
+        const hucResponse: PrimerHeadlessUniversalCheckoutStartResponse = await RNPrimerHeadlessUniversalCheckout.startWithClientToken(clientToken, settings);
+        const availablePaymentMethodTypes: string[] = hucResponse.paymentMethodTypes.filter(pmt => pmt !== 'PAYMENT_CARD');
+        resolve(availablePaymentMethodTypes);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  async showPaymentMethod(paymentMethodType: string): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await RNPrimerHeadlessUniversalCheckout.showPaymentMethod(paymentMethodType);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  getAssetForPaymentMethodType(
+    paymentMethodType: string,
+    assetType: 'logo' | 'icon'
+  ): Promise<string> {
+    return RNPrimerHeadlessUniversalCheckout.getAssetForPaymentMethodType(
+      paymentMethodType,
+      assetType
+    );
+  }
+
+  getAssetForCardNetwork(
+    cardNetwork: string,
+    assetType: 'logo' | 'icon'
+  ): Promise<string> {
+    return RNPrimerHeadlessUniversalCheckout.getAssetForCardNetwork(
+      cardNetwork,
+      assetType
+    );
+  }
+
+  disposePrimerHeadlessUniversalCheckout(): Promise<void> {
+    return RNPrimerHeadlessUniversalCheckout.disposePrimerHeadlessUniversalCheckout();
+  }
+}
+
+export const PrimerHeadlessUniversalCheckout = new PrimerHeadlessUniversalCheckoutClass();

package/src/headless_checkout/RNPrimerHeadlessUniversalCheckout.ts

@@ -0,0 +1,252 @@
+import { NativeEventEmitter, NativeModules } from 'react-native';
+
+const { PrimerHeadlessUniversalCheckout } = NativeModules;
+
+const eventEmitter = new NativeEventEmitter(PrimerHeadlessUniversalCheckout);
+
+type EventType =
+  | 'onHUCTokenizeStart'
+  | 'onHUCPrepareStart'
+  | 'onHUCAvailablePaymentMethodsLoaded'
+  | 'onHUCPaymentMethodShow'
+  | 'onTokenizeSuccess'
+  | 'onResumeSuccess'
+  | 'onBeforePaymentCreate'
+  | 'onBeforeClientSessionUpdate'
+  | 'onClientSessionUpdate'
+  | 'onCheckoutComplete'
+  | 'onError';
+
+const eventTypes: EventType[] = [
+  'onHUCTokenizeStart',
+  'onHUCPrepareStart',
+  'onHUCAvailablePaymentMethodsLoaded',
+  'onHUCPaymentMethodShow',
+  'onTokenizeSuccess',
+  'onResumeSuccess',
+  'onBeforePaymentCreate',
+  'onBeforeClientSessionUpdate',
+  'onClientSessionUpdate',
+  'onCheckoutComplete',
+  'onError'
+];
+
+const RNPrimerHeadlessUniversalCheckout = {
+  ///////////////////////////////////////////
+  // Event Emitter
+  ///////////////////////////////////////////
+  addListener: (eventType: EventType, listener: (...args: any[]) => any) => {
+    eventEmitter.addListener(eventType, listener);
+  },
+
+  removeListener: (eventType: EventType, listener: (...args: any[]) => any) => {
+    eventEmitter.removeListener(eventType, listener);
+  },
+
+  removeAllListenersForEvent(eventType: EventType) {
+    eventEmitter.removeAllListeners(eventType);
+  },
+
+  removeAllListeners() {
+    eventTypes.forEach((eventType) => RNPrimerHeadlessUniversalCheckout.removeAllListenersForEvent(eventType));
+  },
+
+  ///////////////////////////////////////////
+  // 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.getAssetForPaymentMethodType(
+          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);
+      }
+    });
+  },
+
+  ///////////////////////////////////////////
+  // DECISION HANDLERS
+  ///////////////////////////////////////////
+
+  // Tokenization Handlers
+
+  handleTokenizationNewClientToken: (newClientToken: string): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handleTokenizationNewClientToken(newClientToken);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  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> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handleResumeWithNewClientToken(newClientToken);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  handleResumeSuccess: (): 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 || "");
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  // Payment Creation Handlers
+
+  handlePaymentCreationAbort: (errorMessage: string | null): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handlePaymentCreationAbort(errorMessage || "");
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  handlePaymentCreationContinue: (): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handlePaymentCreationContinue();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  // HELPERS
+
+  setImplementedRNCallbacks: (implementedRNCallbacks: any): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.setImplementedRNCallbacks(JSON.stringify(implementedRNCallbacks));
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  
+  disposePrimerHeadlessUniversalCheckout: (): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.disposePrimerHeadlessUniversalCheckout();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+};
+
+export default RNPrimerHeadlessUniversalCheckout;

package/src/headless_checkout/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/index.tsx

@@ -1,4 +1,3 @@
-
 export {
     Primer
 } from './Primer';
@@ -13,7 +12,7 @@ export {
     PrimerTokenizationHandler,
     PrimerResumeHandler,
     PrimerErrorHandler,
-} from './models/Primer';
+} from './models/PrimerInterfaces';
 export { PrimerPaymentMethodTokenData } from './models/PrimerPaymentMethodTokenData';
 export { 
     PrimerClientSession,
@@ -32,3 +31,6 @@ export {
 export { 
     PrimerError
 } from './models/PrimerError';
+export {
+    PrimerHeadlessUniversalCheckout
+} from './headless_checkout/PrimerHeadlessUniversalCheckout';

package/src/models/{Primer.ts → PrimerInterfaces.ts}

@@ -1,7 +1,7 @@
 import type { PrimerSessionIntent } from "./PrimerSessionIntent";
 import type { PrimerSettings } from "./PrimerSettings";
 
-export interface Primer {
+export interface IPrimer {
   configure(settings: PrimerSettings): Promise<void>;
   showUniversalCheckout(clientToken: string): Promise<void>;
   showVaultManager(clientToken: string): Promise<void>;
@@ -11,6 +11,7 @@ export interface Primer {
     clientToken: string
   ): Promise<void>
   dismiss(): void;
+  dispose(): void;
 }
 
 export interface PrimerPaymentCreationHandler {

package/src/models/PrimerSettings.ts

@@ -1,4 +1,9 @@
-import type { PrimerErrorHandler, PrimerPaymentCreationHandler, PrimerResumeHandler, PrimerTokenizationHandler } from "./Primer";
+import type { 
+  PrimerErrorHandler, 
+  PrimerPaymentCreationHandler, 
+  PrimerResumeHandler, 
+  PrimerTokenizationHandler 
+} from "./PrimerInterfaces";
 import type { PrimerCheckoutData } from "./PrimerCheckoutData";
 import type { PrimerCheckoutPaymentMethodData } from "./PrimerCheckoutPaymentMethodData";
 import type { PrimerClientSession } from "./PrimerClientSession";
@@ -15,14 +20,24 @@ 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;
-  onError?: (error: PrimerError, checkoutData: PrimerCheckoutData | null, handler: PrimerErrorHandler) => 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;
 }
 
 //----------------------------------------

package/lib/module/models/Primer.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Primer.js.map

package/lib/typescript/Primer.d.ts

@@ -1,2 +0,0 @@
-import type { Primer as IPrimer } from './models/Primer';
-export declare const Primer: IPrimer;