@finos_sdk/sdk-ekyc 1.2.2 → 1.2.8

package/dist/EKYCModule.js

@@ -9,10 +9,10 @@ const react_native_1 = require("react-native");
 const package_json_1 = __importDefault(require("./package.json"));
 exports.SDK_VERSION = package_json_1.default.version;
 exports.SDK_NAME = package_json_1.default.name;
-const EKYCNativeModule = react_native_1.NativeModules.EKYCModule;
-// Validate that the module is available
+const EKYCNativeModule = react_native_1.NativeModules.EKYCModule || null;
+// Validate that the module is available - but don't throw, just warn
 if (!EKYCNativeModule) {
-    throw new Error('EKYCModule is not available. This is likely an autolinking issue.\n' +
+    console.error('❌ EKYCModule is not available. This is likely an autolinking issue.\n' +
         'Please try:\n' +
         '1. Clean and rebuild your app:\n' +
         '   - rm -rf android/app/build android/build\n' +
@@ -21,35 +21,62 @@ if (!EKYCNativeModule) {
         '2. If using manual linking, remove it and rely on autolinking\n' +
         '3. Ensure you have the latest version: npm install @finos_sdk/sdk-ekyc@latest');
 }
-// Initialize the module with Koin error handling
-try {
-    EKYCNativeModule.initSdkEkyc()
-        .then(() => console.log("✅ EKYCModule.initSdkEkyc called successfully"))
-        .catch(e => {
+else {
+    console.log('✅ Native module loaded');
+    // Initialize the module with Koin error handling
+    try {
+        EKYCNativeModule.initSdkEkyc()
+            .then(() => {
+            console.log("✅ SDK initialized");
+        })
+            .catch(e => {
+            if (e && e.toString().includes('Koin Application has already been started')) {
+                console.log("✅ SDK already initialized");
+            }
+            else {
+                console.warn("❌ Failed to initialize SDK:", e);
+            }
+        });
+    }
+    catch (e) {
         if (e && e.toString().includes('Koin Application has already been started')) {
-            console.log("✅ SDK already initialized (Koin Application started)");
+            console.log("✅ SDK already initialized");
         }
         else {
-            console.warn("❌ Failed to initialize SDK EKYC:", e);
+            console.warn("❌ Exception when initializing SDK:", e);
         }
-    });
-}
-catch (e) {
-    if (e && e.toString().includes('Koin Application has already been started')) {
-        console.log("✅ SDK already initialized (Koin Application started)");
-    }
-    else {
-        console.warn("❌ Exception when calling initSdkEkyc:", e);
     }
 }
 class SDKeKYC {
     constructor() {
+        this.eventEmitter = null;
         this.listeners = [];
         this.isInitialized = false;
-        this.eventEmitter = new react_native_1.NativeEventEmitter(EKYCNativeModule);
+        // Lazy initialization of event emitter to ensure native module is ready
+    }
+    // Ensure event emitter is initialized
+    ensureEventEmitter() {
+        if (!this.eventEmitter) {
+            if (!EKYCNativeModule) {
+                console.error('❌ EKYCModule native module is not available');
+                return null;
+            }
+            try {
+                this.eventEmitter = new react_native_1.NativeEventEmitter(EKYCNativeModule);
+            }
+            catch (error) {
+                console.error('❌ Failed to create NativeEventEmitter:', error);
+                return null;
+            }
+        }
+        return this.eventEmitter;
     }
     // SDK Information methods
     async getVersion() {
+        if (!EKYCNativeModule) {
+            console.warn('⚠️ EKYCModule not available, returning fallback version');
+            return exports.SDK_VERSION;
+        }
         try {
             return await EKYCNativeModule.getVersion();
         }
@@ -59,6 +86,14 @@ class SDKeKYC {
         }
     }
     async getSDKInfo() {
+        if (!EKYCNativeModule) {
+            console.warn('⚠️ EKYCModule not available, returning fallback info');
+            return {
+                name: exports.SDK_NAME,
+                version: exports.SDK_VERSION,
+                buildNumber: '1'
+            };
+        }
         try {
             return await EKYCNativeModule.getSDKInfo();
         }
@@ -73,6 +108,11 @@ class SDKeKYC {
     }
     // Initialize SDK with better error handling
     async initSdkEkyc() {
+        if (!EKYCNativeModule) {
+            const error = 'EKYCModule native module is not available. Please check autolinking.';
+            console.error('❌', error);
+            throw new Error(error);
+        }
         try {
             const result = await EKYCNativeModule.initSdkEkyc();
             this.isInitialized = true;
@@ -94,8 +134,16 @@ class SDKeKYC {
     isSDKInitialized() {
         return this.isInitialized;
     }
+    // Validate native module is available
+    ensureNativeModule() {
+        if (!EKYCNativeModule) {
+            throw new Error('EKYCModule native module is not available. Please check autolinking.');
+        }
+        return EKYCNativeModule;
+    }
     // Validate configuration before calling native methods
     validateConfig(config, requiredFields) {
+        this.ensureNativeModule(); // Check native module first
         if (!this.isInitialized) {
             throw new Error('SDK is not initialized. Please call initSdkEkyc() first.');
         }
@@ -108,8 +156,9 @@ class SDKeKYC {
     async startOcr(config) {
         var _a;
         this.validateConfig(config, ['appKey', 'idImagePath', 'expectedDocumentSide', 'transactionId']);
+        const nativeModule = this.ensureNativeModule();
         try {
-            return await EKYCNativeModule.startOcr(config.appKey, config.idImagePath, config.expectedDocumentSide, (_a = config.transactionId) !== null && _a !== void 0 ? _a : '');
+            return await nativeModule.startOcr(config.appKey, config.idImagePath, config.expectedDocumentSide, (_a = config.transactionId) !== null && _a !== void 0 ? _a : '');
         }
         catch (error) {
             console.error('OCR Error:', error);
@@ -119,8 +168,9 @@ class SDKeKYC {
     // Start NFC scanning
     async startNfcScan(config) {
         this.validateConfig(config, ['appKey', 'documentNumber', 'birthDate', 'expireDate']);
+        const nativeModule = this.ensureNativeModule();
         try {
-            return await EKYCNativeModule.startNfcScan(config.appKey, config.documentNumber, config.birthDate, config.expireDate, config.transactionId, config.facePathStorage);
+            return await nativeModule.startNfcScan(config.appKey, config.documentNumber, config.birthDate, config.expireDate, config.transactionId, config.facePathStorage);
         }
         catch (error) {
             console.error('NFC Scan Error:', error);
@@ -131,8 +181,9 @@ class SDKeKYC {
     async checkC06(config) {
         var _a, _b;
         this.validateConfig(config, ['appKey', 'sod', 'idCardNumber', 'recentLocation']);
+        const nativeModule = this.ensureNativeModule();
         try {
-            return await EKYCNativeModule.checkC06(config.appKey, config.sod, config.idCardNumber, (_a = config.recentLocation) !== null && _a !== void 0 ? _a : '', (_b = config.transactionId) !== null && _b !== void 0 ? _b : '');
+            return await nativeModule.checkC06(config.appKey, config.sod, config.idCardNumber, (_a = config.recentLocation) !== null && _a !== void 0 ? _a : '', (_b = config.transactionId) !== null && _b !== void 0 ? _b : '');
         }
         catch (error) {
             console.error('C06 Check Error:', error);
@@ -142,8 +193,9 @@ class SDKeKYC {
     async startLiveness(config) {
         var _a;
         this.validateConfig(config, ['appKey', 'selfieImage', 'transactionId']);
+        const nativeModule = this.ensureNativeModule();
         try {
-            return await EKYCNativeModule.startLiveness(config.appKey, config.selfieImage, config.usingRandomAction, (_a = config.transactionId) !== null && _a !== void 0 ? _a : '', config.isStraight, config.switchFrontCamera);
+            return await nativeModule.startLiveness(config.appKey, config.selfieImage, config.usingRandomAction, (_a = config.transactionId) !== null && _a !== void 0 ? _a : '', config.isStraight, config.switchFrontCamera !== undefined ? config.switchFrontCamera : false);
         }
         catch (error) {
             console.error('Liveness Error:', error);
@@ -153,8 +205,9 @@ class SDKeKYC {
     async startFaceCompare(config) {
         var _a;
         this.validateConfig(config, ['appKey', 'selfieImage', 'idImage']);
+        const nativeModule = this.ensureNativeModule();
         try {
-            return await EKYCNativeModule.startFaceCompare(config.appKey, (_a = config.transactionId) !== null && _a !== void 0 ? _a : '', config.selfieImage, config.idImage);
+            return await nativeModule.startFaceCompare(config.appKey, (_a = config.transactionId) !== null && _a !== void 0 ? _a : '', config.selfieImage, config.idImage);
         }
         catch (error) {
             console.error('Face Compare Error:', error);
@@ -163,94 +216,619 @@ class SDKeKYC {
     }
     // Lifecycle methods
     onResume() {
-        EKYCNativeModule.onResume();
+        const nativeModule = this.ensureNativeModule();
+        nativeModule.onResume();
     }
     onPause() {
-        EKYCNativeModule.onPause();
+        const nativeModule = this.ensureNativeModule();
+        nativeModule.onPause();
     }
     // Event listeners
     onNfcScanStart(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onNfcScanStart');
+                return null;
+            }
+            const listener = emitter.addListener('onNfcScanStart', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onNfcScanStart listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onNfcScanStart', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     onNfcScanSuccess(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onNfcScanSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onNfcScanSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onNfcScanSuccess listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onNfcScanSuccess', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     onNfcError(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onNfcError');
+                return null;
+            }
+            const listener = emitter.addListener('onNfcError', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onNfcError listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onNfcError', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     onC06Success(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onC06Success');
+                return null;
+            }
+            const listener = emitter.addListener('onC06Success', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onC06Success listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onC06Success', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     onC06Error(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onC06Error');
+                return null;
+            }
+            const listener = emitter.addListener('onC06Error', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onC06Error listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onC06Error', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     // Additional listeners (native emits these):
     onOcrSuccess(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onOcrSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onOcrSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onOcrSuccess listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onOcrSuccess', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     onOcrError(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onOcrError');
+                return null;
+            }
+            const listener = emitter.addListener('onOcrError', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onOcrError listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onOcrError', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     onLivenessSuccess(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onLivenessSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onLivenessSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onLivenessSuccess listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onLivenessSuccess', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     onLivenessError(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onLivenessError');
+                return null;
+            }
+            const listener = emitter.addListener('onLivenessError', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onLivenessError listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onLivenessError', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     onFaceCompareSuccess(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onFaceCompareSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onFaceCompareSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onFaceCompareSuccess listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onFaceCompareSuccess', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     onFaceCompareError(callback) {
-        if (!this.eventEmitter)
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onFaceCompareError');
+                return null;
+            }
+            const listener = emitter.addListener('onFaceCompareError', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onFaceCompareError listener:', error);
             return null;
-        const listener = this.eventEmitter.addListener('onFaceCompareError', callback);
-        this.listeners.push(listener);
-        return listener;
+        }
     }
     removeAllListeners() {
         this.listeners.forEach(listener => listener.remove());
         this.listeners = [];
     }
+    // ==================== SMS OTP Methods ====================
+    async sendOtp(config) {
+        this.validateConfig(config, ['phoneNumber', 'referenceId']);
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.sendOtp(config.phoneNumber, config.purpose || null, config.referenceId);
+            return result;
+        }
+        catch (error) {
+            console.error('SMS OTP Send Error:', error);
+            throw error;
+        }
+    }
+    async verifyOtp(config, otpCode) {
+        if (!config.requestId) {
+            throw new Error('requestId is required for verifyOtp');
+        }
+        this.validateConfig(config, ['phoneNumber', 'referenceId', 'requestId']);
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.verifyOtp(config.phoneNumber, config.purpose || null, config.referenceId, config.requestId, otpCode);
+            return result;
+        }
+        catch (error) {
+            console.error('SMS OTP Verify Error:', error);
+            throw error;
+        }
+    }
+    async resendOtp(config) {
+        if (!config.requestId) {
+            throw new Error('requestId is required for resendOtp');
+        }
+        this.validateConfig(config, ['phoneNumber', 'referenceId', 'requestId']);
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.resendOtp(config.phoneNumber, config.purpose || null, config.referenceId, config.requestId);
+            return result;
+        }
+        catch (error) {
+            console.error('SMS OTP Resend Error:', error);
+            throw error;
+        }
+    }
+    // SMS OTP Event Listeners
+    onSmsOtpSendSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onSmsOtpSendSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onSmsOtpSendSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onSmsOtpSendSuccess listener:', error);
+            return null;
+        }
+    }
+    onSmsOtpVerifySuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onSmsOtpVerifySuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onSmsOtpVerifySuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onSmsOtpVerifySuccess listener:', error);
+            return null;
+        }
+    }
+    onSmsOtpResendSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onSmsOtpResendSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onSmsOtpResendSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onSmsOtpResendSuccess listener:', error);
+            return null;
+        }
+    }
+    onSmsOtpError(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onSmsOtpError');
+                return null;
+            }
+            const listener = emitter.addListener('onSmsOtpError', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onSmsOtpError listener:', error);
+            return null;
+        }
+    }
+    // ==================== eSign Methods ====================
+    async initializeESign() {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.initializeESign();
+            return result;
+        }
+        catch (error) {
+            console.error('eSign Initialize Error:', error);
+            throw error;
+        }
+    }
+    async openSessionId(accessToken, username, rememberMe, userEsignModel, privateKeyFilePath) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const userEsignModelJson = userEsignModel ? JSON.stringify(userEsignModel) : null;
+            const result = await nativeModule.openSessionId(accessToken || null, username || null, rememberMe !== undefined ? rememberMe : false, userEsignModelJson, privateKeyFilePath || null);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign Open Session Error:', error);
+            throw error;
+        }
+    }
+    async registerDevice(recoverCode, pinCode, fcmToken) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.registerDevice(recoverCode, pinCode, fcmToken || null);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign Register Device Error:', error);
+            throw error;
+        }
+    }
+    async listCerts(pageNumber = 1, pageSize = 10) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.listCerts(pageNumber, pageSize);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign List Certs Error:', error);
+            throw error;
+        }
+    }
+    async verifyCert(serial) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.verifyCert(serial);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign Verify Cert Error:', error);
+            throw error;
+        }
+    }
+    async listSignRequest(pageNumber = 1, pageSize = 10) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.listSignRequest(pageNumber, pageSize);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign List Sign Request Error:', error);
+            throw error;
+        }
+    }
+    async confirmSign(signRequestId, pinCode, authId, authData, confirm = true) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.confirmSign(signRequestId, pinCode, authId || null, authData || null, confirm !== undefined ? confirm : true);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign Confirm Sign Error:', error);
+            throw error;
+        }
+    }
+    async authenticate(username, password) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.authenticate(username, password);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign Authenticate Error:', error);
+            throw error;
+        }
+    }
+    async registerRemoteSigning(accessToken, requestJson) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.registerRemoteSigning(accessToken, requestJson);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign Register Remote Signing Error:', error);
+            throw error;
+        }
+    }
+    async signPdf(accessToken, requestJson) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.signPdf(accessToken, requestJson);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign Sign PDF Error:', error);
+            throw error;
+        }
+    }
+    async sendConfirmationDocument(accessToken, requestJson) {
+        const nativeModule = this.ensureNativeModule();
+        try {
+            const result = await nativeModule.sendConfirmationDocument(accessToken, requestJson);
+            return result;
+        }
+        catch (error) {
+            console.error('eSign Send Confirmation Document Error:', error);
+            throw error;
+        }
+    }
+    // eSign Event Listeners
+    onESignInitSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignInitSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignInitSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignInitSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignOpenSessionSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignOpenSessionSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignOpenSessionSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignOpenSessionSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignRegisterDeviceSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignRegisterDeviceSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignRegisterDeviceSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignRegisterDeviceSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignListCertsSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignListCertsSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignListCertsSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignListCertsSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignVerifyCertSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignVerifyCertSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignVerifyCertSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignVerifyCertSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignListSignRequestSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignListSignRequestSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignListSignRequestSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignListSignRequestSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignConfirmSignSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignConfirmSignSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignConfirmSignSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignConfirmSignSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignAuthenticateSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignAuthenticateSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignAuthenticateSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignAuthenticateSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignRegisterRemoteSigningSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignRegisterRemoteSigningSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignRegisterRemoteSigningSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignRegisterRemoteSigningSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignSignPdfSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignSignPdfSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignSignPdfSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignSignPdfSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignSendConfirmationDocumentSuccess(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignSendConfirmationDocumentSuccess');
+                return null;
+            }
+            const listener = emitter.addListener('onESignSendConfirmationDocumentSuccess', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignSendConfirmationDocumentSuccess listener:', error);
+            return null;
+        }
+    }
+    onESignError(callback) {
+        try {
+            const emitter = this.ensureEventEmitter();
+            if (!emitter) {
+                console.error('❌ Event emitter not available for onESignError');
+                return null;
+            }
+            const listener = emitter.addListener('onESignError', callback);
+            this.listeners.push(listener);
+            return listener;
+        }
+        catch (error) {
+            console.error('Failed to add onESignError listener:', error);
+            return null;
+        }
+    }
     // SdkEkycUI method
     async startEkycUI(appKey, flowSDK, language, transactionId, appKeyConfig, optionConfig, styleConfig) {
         if (!this.isInitialized) {
@@ -265,7 +843,8 @@ class SDKeKYC {
             const optionConfigJson = optionConfig ? JSON.stringify(optionConfig) : '{}';
             const appKeyConfigJson = JSON.stringify(appKeyConfig);
             const styleConfigJson = styleConfig ? JSON.stringify(styleConfig) : '{}';
-            const result = await EKYCNativeModule.startEkycUI(appKey, flowSDKJson, language, transactionId, optionConfigJson, appKeyConfigJson, styleConfigJson);
+            const nativeModule = this.ensureNativeModule();
+            const result = await nativeModule.startEkycUI(appKey, flowSDKJson, language, transactionId, optionConfigJson, appKeyConfigJson, styleConfigJson);
             console.log('✅ SdkEkycUI started successfully');
             return result;
         }