@yuno-payments/yuno-sdk-react-native 1.0.17-rc.1 → 1.0.17-rc.11

package/src/YunoSdk.ts

@@ -7,6 +7,11 @@ import type {
   StartPayment,
   SeamlessArguments,
   OneTimeTokenInfo,
+  TokenCollectedData,
+  HeadlessTokenResponse,
+  ThreeDSecureChallengeResponse,
+  EnrollmentCollectedData,
+  HeadlessEnrollmentResponse,
 } from './core/types';
 import { YunoStatus, YunoLanguage, CardFlow } from './core/enums';
 
@@ -89,13 +94,16 @@ export class YunoSdk {
   /**
    * Marks the SDK as initialized without calling the native initialize method.
    * This is useful when the SDK has been initialized from the native side (e.g., in MainActivity/YunoActivity).
-   * 
+   *
    * @param countryCode - ISO country code (e.g., 'US', 'BR', 'CO')
    * @param language - Optional language setting (defaults to EN)
-   * 
+   *
    * @internal
    */
-  static markAsInitialized(countryCode: string = 'CO', language: YunoLanguage = YunoLanguage.EN): void {
+  static markAsInitialized(
+    countryCode: string = 'CO',
+    language: YunoLanguage = YunoLanguage.EN
+  ): void {
     this.countryCode = countryCode;
     this.language = language;
     this.isInitialized = true;
@@ -255,7 +263,11 @@ export class YunoSdk {
   ): Promise<void> {
     this.checkInitialized();
     const code = countryCode ?? this.getCountryCode();
-    return getYunoNative().continuePayment(checkoutSession, code, showPaymentStatus);
+    return getYunoNative().continuePayment(
+      checkoutSession,
+      code,
+      showPaymentStatus
+    );
   }
 
   /**
@@ -373,10 +385,10 @@ export class YunoSdk {
   /**
    * Clears the last OTT tokens stored by the SDK.
    * This is useful to ensure clean state before starting a new payment flow.
-   * 
+   *
    * Note: This is automatically called at the start of each payment/enrollment flow,
    * but you can call it manually if needed.
-   * 
+   *
    * @example
    * ```typescript
    * // Clear OTT before starting a new payment
@@ -535,4 +547,149 @@ export class YunoSdk {
     }
     return this.language;
   }
+
+  // ==================== HEADLESS PAYMENT FLOW ====================
+
+  /**
+   * Generate a one-time token (OTT) from collected payment data using the headless flow.
+   * This method allows you to tokenize payment information without using the UI components.
+   *
+   * @param tokenCollectedData The payment data to tokenize
+   * @param checkoutSession The checkout session ID
+   * @param countryCode The country code for the payment (optional, uses initialized value if not provided)
+   * @returns Promise resolving to the generated token or rejecting with an error
+   *
+   * @example
+   * ```typescript
+   * import { YunoSdk, CardType } from '@yuno-payments/yuno-sdk-react-native';
+   *
+   * try {
+   *   const result = await YunoSdk.generateToken({
+   *     checkoutSession: '73ed16c5-4481-4dce-af42-404b68e21027',
+   *     paymentMethod: {
+   *       type: 'CARD',
+   *       vaultedToken: null,
+   *       card: {
+   *         save: false,
+   *         detail: {
+   *           expirationMonth: 11,
+   *           expirationYear: 25,
+   *           number: '4000000000001091',
+   *           securityCode: '123',
+   *           holderName: 'John Doe',
+   *           type: CardType.CREDIT,
+   *         },
+   *       },
+   *     },
+   *   }, 'checkoutSessionId', 'BR');
+   *
+   *   console.log('Token:', result.token);
+   * } catch (error) {
+   *   console.error('Token generation failed:', error);
+   * }
+   * ```
+   */
+  static async generateToken(
+    tokenCollectedData: TokenCollectedData,
+    checkoutSession: string,
+    countryCode?: string
+  ): Promise<HeadlessTokenResponse> {
+    const native = getYunoNative();
+    const country = countryCode || this.getCountryCode();
+
+    return native.generateToken(tokenCollectedData, checkoutSession, country);
+  }
+
+  /**
+   * Get the 3D Secure challenge URL for a checkout session using the headless flow.
+   * This is typically called after successfully generating a token to handle 3DS verification.
+   *
+   * @param checkoutSession The checkout session ID
+   * @param countryCode The country code for the payment (optional, uses initialized value if not provided)
+   * @returns Promise resolving to the 3DS challenge response
+   *
+   * @example
+   * ```typescript
+   * import { YunoSdk } from '@yuno-payments/yuno-sdk-react-native';
+   *
+   * try {
+   *   // First generate token
+   *   const tokenResult = await YunoSdk.generateToken(paymentData, checkoutSession, 'BR');
+   *
+   *   // Then get 3DS challenge URL if needed
+   *   const challengeResult = await YunoSdk.getThreeDSecureChallenge(checkoutSession, 'BR');
+   *
+   *   if (challengeResult.type === 'URL') {
+   *     console.log('3DS URL:', challengeResult.data);
+   *     // Open this URL in a WebView for the user to complete 3DS verification
+   *   }
+   * } catch (error) {
+   *   console.error('3DS challenge failed:', error);
+   * }
+   * ```
+   */
+  static async getThreeDSecureChallenge(
+    checkoutSession: string,
+    countryCode?: string
+  ): Promise<ThreeDSecureChallengeResponse> {
+    const native = getYunoNative();
+    const country = countryCode || this.getCountryCode();
+
+    return native.getThreeDSecureChallenge(checkoutSession, country);
+  }
+
+  // ==================== HEADLESS ENROLLMENT FLOW ====================
+
+  /**
+   * Continue enrollment to create a vaulted token from collected payment data using the headless flow.
+   * This method allows you to save payment information without using the UI components.
+   *
+   * @param enrollmentCollectedData The enrollment data to process
+   * @param customerSession The customer session ID
+   * @param countryCode The country code for the enrollment (optional, uses initialized value if not provided)
+   * @returns Promise resolving to the vaulted token or rejecting with an error
+   *
+   * @example
+   * ```typescript
+   * import { YunoSdk, CardType } from '@yuno-payments/yuno-sdk-react-native';
+   *
+   * try {
+   *   const result = await YunoSdk.continueEnrollment({
+   *     customerSession: '73ed16c5-4481-4dce-af42-404b68e21027',
+   *     paymentMethod: {
+   *       type: 'CARD',
+   *       card: {
+   *         save: true,
+   *         detail: {
+   *           expirationMonth: 11,
+   *           expirationYear: 25,
+   *           number: '4000000000001091',
+   *           securityCode: '123',
+   *           holderName: 'John Doe',
+   *           type: CardType.CREDIT,
+   *         },
+   *       },
+   *     },
+   *   }, 'customerSessionId', 'BR');
+   *
+   *   console.log('Vaulted Token:', result.vaultedToken);
+   * } catch (error) {
+   *   console.error('Enrollment failed:', error);
+   * }
+   * ```
+   */
+  static async continueEnrollment(
+    enrollmentCollectedData: EnrollmentCollectedData,
+    customerSession: string,
+    countryCode?: string
+  ): Promise<HeadlessEnrollmentResponse> {
+    const native = getYunoNative();
+    const country = countryCode || this.getCountryCode();
+
+    return native.continueEnrollment(
+      enrollmentCollectedData,
+      customerSession,
+      country
+    );
+  }
 }

package/src/core/types/HeadlessTypes.ts

@@ -0,0 +1,110 @@
+/**
+ * Headless Payment Flow Types
+ * These types mirror the native SDK's TokenCollectedData structure
+ */
+
+export enum CardType {
+  CREDIT = 'CREDIT',
+  DEBIT = 'DEBIT',
+}
+
+export interface Detail {
+  expirationMonth?: number;
+  expirationYear?: number;
+  number?: string;
+  securityCode?: string;
+  holderName?: string;
+  type?: CardType;
+}
+
+export interface Installment {
+  id: string;
+  value: number;
+}
+
+export interface CardData {
+  save?: boolean;
+  detail?: Detail;
+  installment?: Installment;
+}
+
+export interface Document {
+  type: string;
+  number: string;
+}
+
+export interface Phone {
+  countryCode: string;
+  number: string;
+}
+
+export interface Address {
+  street?: string;
+  number?: string;
+  complement?: string;
+  neighborhood?: string;
+  city?: string;
+  state?: string;
+  zipCode?: string;
+  country?: string;
+}
+
+export interface Customer {
+  id: string;
+  merchantCustomerId: string;
+  firstName?: string;
+  lastName?: string;
+  dateOfBirth?: string;
+  email?: string;
+  country?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  document?: Document;
+  phone?: Phone;
+  billingAddress?: Address;
+  shippingAddress?: Address;
+}
+
+export interface PaymentMethod {
+  type: string;
+  vaultedToken?: string | null;
+  card?: CardData;
+  customer?: Customer;
+}
+
+export interface TokenCollectedData {
+  checkoutSession?: string;
+  customerSession?: string;
+  paymentMethod: PaymentMethod;
+}
+
+export interface ThreeDSecureChallengeResponse {
+  type: string;
+  data: string;
+}
+
+export interface HeadlessTokenResponse {
+  token?: string;
+  error?: string;
+}
+
+/**
+ * Headless Enrollment Flow Types
+ * These types mirror the native SDK's EnrollmentCollectedData structure
+ */
+
+export interface EnrollmentMethod {
+  type: string;
+  card: CardData;
+  customer?: Customer;
+}
+
+export interface EnrollmentCollectedData {
+  customerSession: string;
+  paymentMethod: EnrollmentMethod;
+}
+
+export interface HeadlessEnrollmentResponse {
+  vaultedToken?: string;
+  error?: string;
+}

package/src/core/types/OneTimeTokenInfo.ts

@@ -204,4 +204,3 @@ export interface OneTimeTokenInfo {
    */
   customer?: CustomerPayerInformation | null;
 }
-

package/src/core/types/index.ts

@@ -5,3 +5,20 @@ export type { EnrollmentArguments } from './EnrollmentArguments';
 export type { StartPayment, MethodSelected } from './StartPayment';
 export type { SeamlessArguments } from './SeamlessArguments';
 export type { OneTimeTokenInfo } from './OneTimeTokenInfo';
+export type {
+  TokenCollectedData,
+  PaymentMethod,
+  CardData,
+  Detail,
+  Installment,
+  Customer,
+  Document,
+  Phone,
+  Address,
+  CardType,
+  ThreeDSecureChallengeResponse,
+  HeadlessTokenResponse,
+  EnrollmentCollectedData,
+  EnrollmentMethod,
+  HeadlessEnrollmentResponse,
+} from './HeadlessTypes';