@finos_sdk/sdk-ekyc 1.2.9 → 1.3.2

package/src/modules/FinosESignModule.ts

@@ -1,7 +1,7 @@
 import { Platform } from 'react-native';
 import sdkEKYC, { SDKeKYC, SDK_VERSION, SDK_NAME } from '../../EKYCModule';
 import { SmsOtpConfig, SmsOtpResult, SmsOtpError } from '../types/ekycSmsOtpType';
-import { UserEsignModel, ESignInitResult, ESignOpenSessionResult, ESignCertificate, ESignSignRequest, ESignError, ESignAuthenticateResult } from '../types/ekycESignType';
+import { ESignInitResult, ESignOpenSessionResult, ESignCertificate, ESignSignRequest, ESignError, ESignAuthenticateResult } from '../types/ekycESignType';
 import { LivenessConfig } from '../types/ekycLivenessType';
 import { FaceServiceConfig } from '../types/ekycFaceType';
 import { SDKEkycResultStringWithEvent, SDKEkycResultWithEvent } from '../types/ekycType';
@@ -94,7 +94,7 @@ export class FinosESignModule {
                 this.isInitialized = true;
                 return 'SDK already initialized (Koin Application started)';
             }
-            
+
             console.error('❌ Failed to initialize Finos eSign SDK:', error);
             throw new Error(`SDK initialization failed: ${error}`);
         }
@@ -115,16 +115,8 @@ export class FinosESignModule {
      */
     public async sendOtp(config: SmsOtpConfig): Promise<SmsOtpResult> {
         this.validateSDKReady();
-        
-        try {
-            console.log('📱 Sending SMS OTP...');
-            const result = await this.sdk.sendOtp(config);
-            console.log('✅ SMS OTP sent successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ SMS OTP send failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.sendOtp(config);
     }
 
     /**
@@ -134,16 +126,8 @@ export class FinosESignModule {
      */
     public async verifyOtp(config: SmsOtpConfig, otpCode: string): Promise<SmsOtpResult> {
         this.validateSDKReady();
-        
-        try {
-            console.log('🔐 Verifying SMS OTP...');
-            const result = await this.sdk.verifyOtp(config, otpCode);
-            console.log('✅ SMS OTP verified successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ SMS OTP verification failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.verifyOtp(config, otpCode);
     }
 
     /**
@@ -152,16 +136,8 @@ export class FinosESignModule {
      */
     public async resendOtp(config: SmsOtpConfig): Promise<SmsOtpResult> {
         this.validateSDKReady();
-        
-        try {
-            console.log('📱 Resending SMS OTP...');
-            const result = await this.sdk.resendOtp(config);
-            console.log('✅ SMS OTP resent successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ SMS OTP resend failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.resendOtp(config);
     }
 
     // SMS OTP Event Listeners
@@ -201,55 +177,50 @@ export class FinosESignModule {
 
     /**
      * Initialize eSign SDK
+     * @param finosToken Optional access token (Client Credentials)
      */
-    public async initializeESign(): Promise<ESignInitResult> {
+    public async initializeESign(finosToken?: string): Promise<ESignInitResult> {
         this.validateSDKReady();
-        
-        try {
-            console.log('🔐 Initializing eSign SDK...');
-            const result = await this.sdk.initializeESign();
-            console.log('✅ eSign SDK initialized successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ eSign initialization failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.initializeESign(finosToken);
     }
 
     /**
-     * Open eSign session
-     * @param accessToken JWT access token (optional if using userEsignModel)
-     * @param username Optional username
-     * @param rememberMe Remember session
-     * @param userEsignModel User info for auto token creation (optional if using accessToken)
-     * @param privateKeyFilePath Path to private key file in assets (required if using userEsignModel)
+     * Get SDK Token for Session
+     * @param identity User Identity (CCCD/CMND)
+     * @param name User Name
+     * @param deviceId Device ID
+     */
+    public async getSdkToken(identity: string, name: string, deviceId: string): Promise<string> {
+        this.validateSDKReady();
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.getSdkToken(identity, name, deviceId);
+    }
+
+
+    /**
+     * Open eSign Session
+     * @param accessToken Access token (JWT)
+     * @param username Username
+     * @param rememberMe Remember me flag
+     * @param userEsignModel User info model (for auto-token generation)
+     * @param privateKeyFilePath Path to private key file (for auto-token generation)
      */
     public async openSessionId(
-        accessToken?: string,
-        username?: string,
-        rememberMe?: boolean,
-        userEsignModel?: UserEsignModel,
-        privateKeyFilePath?: string
+        accessToken: string | null,
+        username: string | null,
+        rememberMe: boolean | null
     ): Promise<ESignOpenSessionResult> {
         this.validateSDKReady();
-        
-        try {
-            console.log('🔓 Opening eSign session...');
-            const result = await this.sdk.openSessionId(
-                accessToken,
-                username,
-                rememberMe,
-                userEsignModel,
-                privateKeyFilePath
-            );
-            console.log('✅ eSign session opened successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ eSign session open failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.openSessionId(
+            accessToken,
+            username,
+            rememberMe
+        );
     }
 
+
     /**
      * Register device for eSign
      * @param recoverCode 8-digit recovery code
@@ -262,16 +233,8 @@ export class FinosESignModule {
         fcmToken?: string
     ): Promise<{ code: string; message: string }> {
         this.validateSDKReady();
-        
-        try {
-            console.log('📱 Registering eSign device...');
-            const result = await this.sdk.registerDevice(recoverCode, pinCode, fcmToken);
-            console.log('✅ eSign device registered successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ eSign device registration failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.registerDevice(recoverCode, pinCode, fcmToken);
     }
 
     /**
@@ -284,16 +247,8 @@ export class FinosESignModule {
         pageSize: number = 10
     ): Promise<{ certs: ESignCertificate[] }> {
         this.validateSDKReady();
-        
-        try {
-            console.log('📋 Listing eSign certificates...');
-            const result = await this.sdk.listCerts(pageNumber, pageSize);
-            console.log(`✅ Found ${result.certs.length} certificates`);
-            return result;
-        } catch (error) {
-            console.error('❌ eSign list certificates failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.listCerts(pageNumber, pageSize);
     }
 
     /**
@@ -302,16 +257,8 @@ export class FinosESignModule {
      */
     public async verifyCert(serial: string): Promise<{ code: string; message: string }> {
         this.validateSDKReady();
-        
-        try {
-            console.log('✅ Verifying eSign certificate...');
-            const result = await this.sdk.verifyCert(serial);
-            console.log('✅ eSign certificate verified successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ eSign certificate verification failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.verifyCert(serial);
     }
 
     /**
@@ -324,16 +271,8 @@ export class FinosESignModule {
         pageSize: number = 10
     ): Promise<{ requests: ESignSignRequest[] }> {
         this.validateSDKReady();
-        
-        try {
-            console.log('📋 Listing eSign sign requests...');
-            const result = await this.sdk.listSignRequest(pageNumber, pageSize);
-            console.log(`✅ Found ${result.requests.length} sign requests`);
-            return result;
-        } catch (error) {
-            console.error('❌ eSign list sign requests failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.listSignRequest(pageNumber, pageSize);
     }
 
     /**
@@ -352,104 +291,46 @@ export class FinosESignModule {
         confirm: boolean = true
     ): Promise<{ code: string; message: string }> {
         this.validateSDKReady();
-        
-        try {
-            console.log('✍️ Confirming eSign signature...');
-            const result = await this.sdk.confirmSign(signRequestId, pinCode, authId, authData, confirm);
-            console.log('✅ eSign signature confirmed successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ eSign signature confirmation failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.confirmSign(signRequestId, pinCode, authId, authData, confirm);
     }
 
-    /**
-     * Authenticate with eSign
-     * @param username eSign username
-     * @param password eSign password
-     */
-    public async authenticate(
-        username: string,
-        password: string
-    ): Promise<ESignAuthenticateResult> {
-        this.validateSDKReady();
-        
-        try {
-            console.log('🔐 Authenticating with eSign...');
-            const result = await this.sdk.authenticate(username, password);
-            console.log('✅ eSign authentication successful');
-            return result;
-        } catch (error) {
-            console.error('❌ eSign authentication failed:', error);
-            throw error;
-        }
-    }
+
 
     /**
      * Register remote signing certificate
-     * @param accessToken JWT access token
      * @param requestJson JSON request body
      */
     public async registerRemoteSigning(
-        accessToken: string,
         requestJson: string
     ): Promise<{ response: string }> {
         this.validateSDKReady();
-        
-        try {
-            console.log('📝 Registering remote signing certificate...');
-            const result = await this.sdk.registerRemoteSigning(accessToken, requestJson);
-            console.log('✅ Remote signing certificate registered successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ Remote signing certificate registration failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.registerRemoteSigning(requestJson);
     }
 
     /**
      * Sign PDF document
-     * @param accessToken JWT access token
      * @param requestJson JSON request body
      */
     public async signPdf(
-        accessToken: string,
         requestJson: string
     ): Promise<{ response: string }> {
         this.validateSDKReady();
-        
-        try {
-            console.log('📄 Signing PDF document...');
-            const result = await this.sdk.signPdf(accessToken, requestJson);
-            console.log('✅ PDF document signed successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ PDF document signing failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.signPdf(requestJson);
     }
 
     /**
      * Send confirmation document
-     * @param accessToken JWT access token
      * @param requestJson JSON string containing request data
      */
     public async sendConfirmationDocument(
-        accessToken: string,
         requestJson: string
     ): Promise<{ response: string }> {
         this.validateSDKReady();
-        
-        try {
-            console.log('📧 Sending confirmation document...');
-            const result = await this.sdk.sendConfirmationDocument(accessToken, requestJson);
-            console.log('✅ Confirmation document sent successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ Confirmation document sending failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.sendConfirmationDocument(requestJson);
     }
 
     /**
@@ -517,13 +398,7 @@ export class FinosESignModule {
         return listener;
     }
 
-    public onESignAuthenticateSuccess(callback: (data: ESignAuthenticateResult) => void) {
-        const listener = this.sdk.onESignAuthenticateSuccess(callback);
-        if (!listener) {
-            console.warn('⚠️ onESignAuthenticateSuccess: Event emitter not ready.');
-        }
-        return listener;
-    }
+
 
     public onESignRegisterRemoteSigningSuccess(callback: (data: { response: string }) => void) {
         const listener = this.sdk.onESignRegisterRemoteSigningSuccess(callback);
@@ -561,23 +436,18 @@ export class FinosESignModule {
 
     /**
      * Start liveness detection
-     * @param config Liveness configuration (includes switchFrontCamera for camera control)
+     * @param config Liveness configuration
+     * @param config.isActiveLiveness - Enable active liveness detection (default: false)
+     * @param config.autoCapture - Enable auto capture (default: true)
+     * @param config.isShowCameraFont - Show camera font (default: true)
+     * @param config.customActions - Custom actions array (LEFT, RIGHT, STRAIGHT). If provided, uses these actions instead of random
+     * @param config.activeActionCount - Number of random actions (1-10), only used when customActions is null (default: 2)
+     * @param config.switchFrontCamera - Use front camera (default: false)
      */
     public async startLiveness(config: LivenessConfig): Promise<SDKEkycResultStringWithEvent> {
         this.validateSDKReady();
-        
-        try {
-            console.log('👁️ Starting liveness detection...');
-            if (config.switchFrontCamera !== undefined) {
-                console.log('📷 Front camera setting:', config.switchFrontCamera ? 'ON' : 'OFF');
-            }
-            const result = await this.sdk.startLiveness(config);
-            console.log('✅ Liveness detection completed:', result.event);
-            return result;
-        } catch (error) {
-            console.error('❌ Liveness detection failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.startLiveness(config);
     }
 
     // Liveness Event Listeners
@@ -597,16 +467,8 @@ export class FinosESignModule {
      */
     public async startFaceCompare(config: FaceServiceConfig): Promise<SDKEkycResultStringWithEvent> {
         this.validateSDKReady();
-        
-        try {
-            console.log('👤 Starting face comparison...');
-            const result = await this.sdk.startFaceCompare(config);
-            console.log('✅ Face comparison completed:', result.event);
-            return result;
-        } catch (error) {
-            console.error('❌ Face comparison failed:', error);
-            throw error;
-        }
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.startFaceCompare(config);
     }
 
     // Face Compare Event Listeners
@@ -686,7 +548,7 @@ export class FinosESignModule {
         }
     ): Promise<any> {
         this.validateSDKReady();
-        
+
         // Validate flowSDK - only allow LIVENESS and FACE
         const allowedTypes = ['LIVENESS', 'FACE'];
         const invalidTypes = flowSDK.filter(type => !allowedTypes.includes(type));
@@ -697,41 +559,27 @@ export class FinosESignModule {
         if (flowSDK.length === 0) {
             throw new Error('flowSDK must contain at least one SDK type (LIVENESS or FACE)');
         }
-        
-        try {
-            console.log('🚀 Starting eKYC UI with flow:', flowSDK);
-            console.log('🔧 OptionConfig:', optionConfig);
-            if (optionConfig?.switchFrontCamera !== undefined) {
-                console.log('📷 Front camera setting:', optionConfig.switchFrontCamera ? 'ON' : 'OFF');
-            }
-            console.log('🔑 AppKeyConfig:', appKeyConfig);
-            console.log('🎨 StyleConfig:', styleConfig);
-            
-            // Create full appKeyConfig with empty values for excluded modules
-            const fullAppKeyConfig = {
-                appKey: appKeyConfig.appKey,
-                appKeyNfc: '',
-                appKeyOcr: '',
-                appKeyLiveness: appKeyConfig.appKeyLiveness,
-                appKeyC06: '',
-                appKeyFaceService: appKeyConfig.appKeyFaceService,
-            };
-            
-            const result = await this.sdk.startEkycUI(
-                appKey,
-                flowSDK,
-                language,
-                transactionId,
-                fullAppKeyConfig,
-                optionConfig,
-                styleConfig
-            );
-            console.log('✅ eKYC UI started successfully');
-            return result;
-        } catch (error) {
-            console.error('❌ eKYC UI failed:', error);
-            throw error;
-        }
+
+        // Create full appKeyConfig with empty values for excluded modules
+        const fullAppKeyConfig = {
+            appKey: appKeyConfig.appKey,
+            appKeyNfc: '',
+            appKeyOcr: '',
+            appKeyLiveness: appKeyConfig.appKeyLiveness,
+            appKeyC06: '',
+            appKeyFaceService: appKeyConfig.appKeyFaceService,
+        };
+
+        // Pass through to SDK - error handling is done in EKYCModule.ts
+        return await this.sdk.startEkycUI(
+            appKey,
+            flowSDK,
+            language,
+            transactionId,
+            fullAppKeyConfig,
+            optionConfig,
+            styleConfig
+        );
     }
 
     // Private validation methods
@@ -769,26 +617,27 @@ const isMethod = (prop: string | symbol): boolean => {
     if (typeof prop !== 'string') return false;
     // Check if it's a known method from the class
     const prototype = FinosESignModule.prototype as any;
-    return typeof prototype[prop] === 'function' || 
-           prop.startsWith('on') || 
-           prop === 'initialize' || 
-           prop === 'initializeESign' ||
-           prop === 'sendOtp' ||
-           prop === 'verifyOtp' ||
-           prop === 'resendOtp' ||
-           prop === 'openSessionId' ||
-           prop === 'registerDevice' ||
-           prop === 'listCerts' ||
-           prop === 'verifyCert' ||
-           prop === 'listSignRequest' ||
-           prop === 'confirmSign' ||
-           prop === 'authenticate' ||
-           prop === 'registerRemoteSigning' ||
-           prop === 'signPdf' ||
-           prop === 'sendConfirmationDocument' ||
-           prop === 'startLiveness' ||
-           prop === 'startFaceCompare' ||
-           prop === 'startEkycUI';
+    return typeof prototype[prop] === 'function' ||
+        prop.startsWith('on') ||
+        prop === 'initialize' ||
+        prop === 'initializeESign' ||
+        prop === 'getSdkToken' ||
+        prop === 'openSessionId' ||
+        prop === 'sendOtp' ||
+        prop === 'verifyOtp' ||
+        prop === 'resendOtp' ||
+
+        prop === 'registerDevice' ||
+        prop === 'listCerts' ||
+        prop === 'verifyCert' ||
+        prop === 'listSignRequest' ||
+        prop === 'confirmSign' ||
+        prop === 'registerRemoteSigning' ||
+        prop === 'signPdf' ||
+        prop === 'sendConfirmationDocument' ||
+        prop === 'startLiveness' ||
+        prop === 'startFaceCompare' ||
+        prop === 'startEkycUI';
 };
 
 // Create a safe wrapper using Proxy - ensure it's always an object
@@ -834,39 +683,40 @@ const createFinosESignProxy = (): FinosESignModule => {
 // Create a comprehensive stub object with all methods to prevent undefined errors
 const createFinosESignStub = (): FinosESignModule => {
     const stub = {} as any;
-    
+
     // Add all event listener methods (on* methods)
     const eventListenerMethods = [
         'onSmsOtpSendSuccess', 'onSmsOtpVerifySuccess', 'onSmsOtpResendSuccess', 'onSmsOtpError',
         'onESignInitSuccess', 'onESignOpenSessionSuccess', 'onESignRegisterDeviceSuccess',
         'onESignListCertsSuccess', 'onESignVerifyCertSuccess', 'onESignListSignRequestSuccess',
-        'onESignConfirmSignSuccess', 'onESignAuthenticateSuccess', 'onESignRegisterRemoteSigningSuccess',
+        'onESignConfirmSignSuccess', 'onESignRegisterRemoteSigningSuccess',
         'onESignSignPdfSuccess', 'onESignSendConfirmationDocumentSuccess', 'onESignError',
         'onLivenessSuccess', 'onLivenessError', 'onFaceCompareSuccess', 'onFaceCompareError'
     ];
-    
+
     eventListenerMethods.forEach(method => {
         stub[method] = (callback?: any) => {
             console.warn(`⚠️ FinosESign.${method} called but module is not initialized`);
             return null;
         };
     });
-    
+
     // Add all other methods
     const otherMethods = [
-        'initialize', 'initializeESign', 'sendOtp', 'verifyOtp', 'resendOtp',
-        'openSessionId', 'registerDevice', 'listCerts', 'verifyCert', 'listSignRequest',
-        'confirmSign', 'authenticate', 'registerRemoteSigning', 'signPdf', 'sendConfirmationDocument',
-        'startLiveness', 'startFaceCompare', 'startEkycUI', 'isSDKReady', 'getSDKInfo'
+        'initialize', 'startNfcScan', 'checkC06', 'startOcr', 'startLiveness', 'startFaceCompare',
+        'startEkycUI', 'sendOtp', 'verifyOtp', 'resendOtp', 'initializeESign', 'getSdkToken', 'openSessionId',
+        'registerDevice', 'listCerts', 'verifyCert', 'listSignRequest', 'confirmSign',
+        'registerRemoteSigning', 'signPdf', 'sendConfirmationDocument',
+        'onResume', 'onPause', 'isSDKReady', 'getSDKInfo'
     ];
-    
+
     otherMethods.forEach(method => {
         stub[method] = async (...args: any[]) => {
             console.warn(`⚠️ FinosESign.${method} called but module is not initialized`);
             throw new Error(`FinosESign.${method} is not available. Module may not be initialized.`);
         };
     });
-    
+
     return stub as FinosESignModule;
 };
 
@@ -876,18 +726,18 @@ const createFinosESignWrapper = (): FinosESignModule => {
     // Always start with stub to ensure all methods exist
     const stub = createFinosESignStub();
     const wrapper = { ...stub } as any;
-    
+
     // Try to get real instance and override methods
     try {
         const realInstance = getFinosESignInstance();
-        
+
         // Override with real instance methods
         Object.getOwnPropertyNames(Object.getPrototypeOf(realInstance)).forEach(key => {
             if (key !== 'constructor' && typeof (realInstance as any)[key] === 'function') {
                 wrapper[key] = ((realInstance as any)[key]).bind(realInstance);
             }
         });
-        
+
         // Also copy any own properties from real instance
         Object.keys(realInstance).forEach(key => {
             if ((realInstance as any)[key] !== undefined) {
@@ -898,7 +748,7 @@ const createFinosESignWrapper = (): FinosESignModule => {
         // If we can't get instance, wrapper already has all stub methods
         // No need to do anything
     }
-    
+
     return wrapper as FinosESignModule;
 };
 
@@ -907,8 +757,9 @@ export const FinosESign = createFinosESignWrapper();
 
 // Export types
 export type { SmsOtpConfig, SmsOtpResult, SmsOtpError } from '../types/ekycSmsOtpType';
-export type { UserEsignModel, ESignInitResult, ESignOpenSessionResult, ESignCertificate, ESignSignRequest, ESignError, ESignAuthenticateResult } from '../types/ekycESignType';
+export type { ESignInitResult, ESignOpenSessionResult, ESignCertificate, ESignSignRequest, ESignError, ESignAuthenticateResult } from '../types/ekycESignType';
 export type { LivenessConfig } from '../types/ekycLivenessType';
+export { SDKFaceDetectStatus } from '../types/ekycLivenessType';
 export type { FaceServiceConfig } from '../types/ekycFaceType';
 export type { SDKEkycResultStringWithEvent, SDKEkycResultWithEvent } from '../types/ekycType';
 

package/src/modules/README.md

@@ -100,14 +100,20 @@ try {
 ### Liveness Detection
 
 ```typescript
-import { finosEKYC, LivenessConfig } from '@finos_sdk/sdk-ekyc';
+import { finosEKYC, LivenessConfig, SDKFaceDetectStatus } from '@finos_sdk/sdk-ekyc';
 
 const livenessConfig: LivenessConfig = {
   appKey: 'your-app-key',
   selfieImage: 'base64-selfie-data',
   usingRandomAction: true,
   transactionId: 'txn-123',
-  isStraight: true
+  isStraight: true,
+  // New parameters for version 1.3.0
+  isActiveLiveness: true,
+  autoCapture: true,
+  isShowCameraFont: true,
+  customActions: [SDKFaceDetectStatus.LEFT, SDKFaceDetectStatus.RIGHT],
+  activeActionCount: 2
 };
 
 try {
@@ -269,6 +275,19 @@ interface LivenessConfig {
   usingRandomAction: boolean;
   transactionId: string;
   isStraight: boolean;
+  switchFrontCamera?: boolean;
+  // New parameters for version 1.3.0
+  isActiveLiveness?: boolean; // Enable active liveness detection (default: false)
+  autoCapture?: boolean;      // Enable auto capture (default: true)
+  isShowCameraFont?: boolean; // Show camera font (default: true)
+  customActions?: SDKFaceDetectStatus[]; // Custom actions array (LEFT, RIGHT, STRAIGHT)
+  activeActionCount?: number; // Number of random actions (1-10), only used when customActions = null (default: 2)
+}
+
+enum SDKFaceDetectStatus {
+  LEFT = "LEFT",
+  RIGHT = "RIGHT",
+  STRAIGHT = "STRAIGHT"
 }
 ```