@finos_sdk/sdk-ekyc 1.2.2 → 1.2.8

package/dist/src/modules/FinosESignModule.js

@@ -0,0 +1,752 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_NAME = exports.SDK_VERSION = exports.FinosESign = exports.FinosESignModule = void 0;
+const react_native_1 = require("react-native");
+const EKYCModule_1 = __importStar(require("../../EKYCModule"));
+Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return EKYCModule_1.SDK_VERSION; } });
+Object.defineProperty(exports, "SDK_NAME", { enumerable: true, get: function () { return EKYCModule_1.SDK_NAME; } });
+/**
+ * Finos eSign SDK Module
+ *
+ * A React Native module for eSign (Electronic Signature), SMS OTP, Liveness detection,
+ * and Face matching operations. This module excludes NFC, C06, and OCR features.
+ *
+ * @version Dynamic from package.json
+ * @author FinOS
+ * @license MIT
+ */
+class FinosESignModule {
+    constructor() {
+        this.isInitialized = false;
+        this.sdk = EKYCModule_1.default;
+        this.platform = react_native_1.Platform.OS;
+    }
+    /**
+     * Get singleton instance of FinosESignModule
+     */
+    static getInstance() {
+        if (!FinosESignModule.instance) {
+            FinosESignModule.instance = new FinosESignModule();
+        }
+        return FinosESignModule.instance;
+    }
+    /**
+     * Get SDK information
+     */
+    async getSDKInfo() {
+        try {
+            const nativeInfo = await this.sdk.getSDKInfo();
+            return Object.assign(Object.assign({}, nativeInfo), { platform: this.platform, isInitialized: this.isInitialized });
+        }
+        catch (error) {
+            return {
+                name: EKYCModule_1.SDK_NAME,
+                version: EKYCModule_1.SDK_VERSION,
+                buildNumber: '1',
+                platform: this.platform,
+                isInitialized: this.isInitialized
+            };
+        }
+    }
+    /**
+     * Initialize the eSign SDK
+     * Must be called before using any other methods
+     */
+    async initialize() {
+        try {
+            if (this.isInitialized) {
+                console.log('✅ SDK already initialized');
+                return 'SDK already initialized';
+            }
+            // Check if SDK is already initialized on native side
+            if (this.sdk.isSDKInitialized()) {
+                this.isInitialized = true;
+                console.log('✅ SDK already initialized on native side');
+                return 'SDK already initialized on native side';
+            }
+            const result = await this.sdk.initSdkEkyc();
+            this.isInitialized = true;
+            console.log(`✅ Finos eSign SDK v${EKYCModule_1.SDK_VERSION} initialized successfully`);
+            return result;
+        }
+        catch (error) {
+            // Handle Koin Application already started error
+            if (error && error.toString().includes('Koin Application has already been started')) {
+                console.log('✅ SDK already initialized (Koin Application started)');
+                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}`);
+        }
+    }
+    /**
+     * Check if SDK is initialized
+     */
+    isSDKReady() {
+        return this.isInitialized && this.sdk.isSDKInitialized();
+    }
+    // ==================== SMS OTP Methods ====================
+    /**
+     * Send SMS OTP
+     * @param config SMS OTP configuration
+     */
+    async sendOtp(config) {
+        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;
+        }
+    }
+    /**
+     * Verify SMS OTP
+     * @param config SMS OTP configuration (must include requestId)
+     * @param otpCode OTP code from SMS
+     */
+    async verifyOtp(config, otpCode) {
+        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;
+        }
+    }
+    /**
+     * Resend SMS OTP
+     * @param config SMS OTP configuration (must include requestId)
+     */
+    async resendOtp(config) {
+        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;
+        }
+    }
+    // SMS OTP Event Listeners
+    onSmsOtpSendSuccess(callback) {
+        const listener = this.sdk.onSmsOtpSendSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpSendSuccess: Event emitter not ready. Make sure SDK is initialized.');
+        }
+        return listener;
+    }
+    onSmsOtpVerifySuccess(callback) {
+        const listener = this.sdk.onSmsOtpVerifySuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpVerifySuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onSmsOtpResendSuccess(callback) {
+        const listener = this.sdk.onSmsOtpResendSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpResendSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onSmsOtpError(callback) {
+        const listener = this.sdk.onSmsOtpError(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpError: Event emitter not ready.');
+        }
+        return listener;
+    }
+    // ==================== eSign Methods ====================
+    /**
+     * Initialize eSign SDK
+     */
+    async initializeESign() {
+        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;
+        }
+    }
+    /**
+     * 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)
+     */
+    async openSessionId(accessToken, username, rememberMe, userEsignModel, privateKeyFilePath) {
+        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;
+        }
+    }
+    /**
+     * Register device for eSign
+     * @param recoverCode 8-digit recovery code
+     * @param pinCode 6-digit PIN code
+     * @param fcmToken Optional FCM token
+     */
+    async registerDevice(recoverCode, pinCode, fcmToken) {
+        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;
+        }
+    }
+    /**
+     * List eSign certificates
+     * @param pageNumber Page number (default: 1)
+     * @param pageSize Page size (default: 10)
+     */
+    async listCerts(pageNumber = 1, pageSize = 10) {
+        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;
+        }
+    }
+    /**
+     * Verify eSign certificate
+     * @param serial Certificate serial number
+     */
+    async verifyCert(serial) {
+        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;
+        }
+    }
+    /**
+     * List eSign sign requests
+     * @param pageNumber Page number (default: 1)
+     * @param pageSize Page size (default: 10)
+     */
+    async listSignRequest(pageNumber = 1, pageSize = 10) {
+        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;
+        }
+    }
+    /**
+     * Confirm eSign signature
+     * @param signRequestId Sign request ID
+     * @param pinCode 6-digit PIN code
+     * @param authId Optional auth ID
+     * @param authData Optional auth data
+     * @param confirm Confirm the signature (default: true)
+     */
+    async confirmSign(signRequestId, pinCode, authId, authData, confirm = true) {
+        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;
+        }
+    }
+    /**
+     * Authenticate with eSign
+     * @param username eSign username
+     * @param password eSign password
+     */
+    async authenticate(username, password) {
+        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
+     */
+    async registerRemoteSigning(accessToken, requestJson) {
+        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;
+        }
+    }
+    /**
+     * Sign PDF document
+     * @param accessToken JWT access token
+     * @param requestJson JSON request body
+     */
+    async signPdf(accessToken, requestJson) {
+        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;
+        }
+    }
+    /**
+     * Send confirmation document
+     * @param accessToken JWT access token
+     * @param requestJson JSON string containing request data
+     */
+    async sendConfirmationDocument(accessToken, requestJson) {
+        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;
+        }
+    }
+    /**
+     * Remove all event listeners
+     */
+    removeAllListeners() {
+        this.sdk.removeAllListeners();
+        console.log('🧹 All event listeners removed');
+    }
+    // eSign Event Listeners
+    onESignInitSuccess(callback) {
+        const listener = this.sdk.onESignInitSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignInitSuccess: Event emitter not ready. Make sure SDK is initialized.');
+        }
+        return listener;
+    }
+    onESignOpenSessionSuccess(callback) {
+        const listener = this.sdk.onESignOpenSessionSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignOpenSessionSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onESignRegisterDeviceSuccess(callback) {
+        const listener = this.sdk.onESignRegisterDeviceSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignRegisterDeviceSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onESignListCertsSuccess(callback) {
+        const listener = this.sdk.onESignListCertsSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignListCertsSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onESignVerifyCertSuccess(callback) {
+        const listener = this.sdk.onESignVerifyCertSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignVerifyCertSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onESignListSignRequestSuccess(callback) {
+        const listener = this.sdk.onESignListSignRequestSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignListSignRequestSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onESignConfirmSignSuccess(callback) {
+        const listener = this.sdk.onESignConfirmSignSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignConfirmSignSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onESignAuthenticateSuccess(callback) {
+        const listener = this.sdk.onESignAuthenticateSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignAuthenticateSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onESignRegisterRemoteSigningSuccess(callback) {
+        const listener = this.sdk.onESignRegisterRemoteSigningSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignRegisterRemoteSigningSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onESignSignPdfSuccess(callback) {
+        const listener = this.sdk.onESignSignPdfSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignSignPdfSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onESignSendConfirmationDocumentSuccess(callback) {
+        const listener = this.sdk.onESignSendConfirmationDocumentSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignSendConfirmationDocumentSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onESignError(callback) {
+        const listener = this.sdk.onESignError(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignError: Event emitter not ready.');
+        }
+        return listener;
+    }
+    // ==================== Liveness Methods ====================
+    /**
+     * Start liveness detection
+     * @param config Liveness configuration (includes switchFrontCamera for camera control)
+     */
+    async startLiveness(config) {
+        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;
+        }
+    }
+    // Liveness Event Listeners
+    onLivenessSuccess(callback) {
+        return this.sdk.onLivenessSuccess(callback);
+    }
+    onLivenessError(callback) {
+        return this.sdk.onLivenessError(callback);
+    }
+    // ==================== Face Service Methods ====================
+    /**
+     * Start face comparison
+     * @param config Face service configuration
+     */
+    async startFaceCompare(config) {
+        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;
+        }
+    }
+    // Face Compare Event Listeners
+    onFaceCompareSuccess(callback) {
+        return this.sdk.onFaceCompareSuccess(callback);
+    }
+    onFaceCompareError(callback) {
+        return this.sdk.onFaceCompareError(callback);
+    }
+    // ==================== eKYC UI Methods ====================
+    /**
+     * Start eKYC UI with flow (excluding NFC, C06, OCR)
+     * Only supports LIVENESS and FACE in flowSDK array
+     * @param appKey Main app key
+     * @param flowSDK Array of SDK types (only 'LIVENESS' and 'FACE' are allowed)
+     * @param language Language code (vi/en)
+     * @param transactionId Transaction ID
+     * @param appKeyConfig App key configuration
+     * @param optionConfig Optional configuration settings (includes switchFrontCamera for camera control)
+     * @param styleConfig Optional style configuration
+     */
+    async startEkycUI(appKey, flowSDK, language, transactionId, appKeyConfig, optionConfig, styleConfig) {
+        this.validateSDKReady();
+        // Validate flowSDK - only allow LIVENESS and FACE
+        const allowedTypes = ['LIVENESS', 'FACE'];
+        const invalidTypes = flowSDK.filter(type => !allowedTypes.includes(type));
+        if (invalidTypes.length > 0) {
+            throw new Error(`Invalid SDK types in flowSDK: ${invalidTypes.join(', ')}. Only 'LIVENESS' and 'FACE' are allowed in 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 === null || optionConfig === void 0 ? void 0 : 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;
+        }
+    }
+    // Private validation methods
+    validateSDKReady() {
+        if (!this.isSDKReady()) {
+            throw new Error('SDK is not initialized. Please call initialize() first.');
+        }
+    }
+}
+exports.FinosESignModule = FinosESignModule;
+// Export singleton instance - ensure it's always initialized
+let _finosESignInstance = null;
+const getFinosESignInstance = () => {
+    if (!_finosESignInstance) {
+        try {
+            _finosESignInstance = FinosESignModule.getInstance();
+        }
+        catch (error) {
+            console.error('Failed to initialize FinosESignModule:', error);
+            throw new Error('FinosESignModule initialization failed. Please check native module setup.');
+        }
+    }
+    return _finosESignInstance;
+};
+// Initialize immediately
+try {
+    _finosESignInstance = FinosESignModule.getInstance();
+}
+catch (error) {
+    // Silent initialization - will be created on first access
+}
+// Helper to check if a property is a method on FinosESignModule
+const isMethod = (prop) => {
+    if (typeof prop !== 'string')
+        return false;
+    // Check if it's a known method from the class
+    const prototype = FinosESignModule.prototype;
+    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';
+};
+// Create a safe wrapper using Proxy - ensure it's always an object
+const createFinosESignProxy = () => {
+    try {
+        return new Proxy({}, {
+            get(_target, prop) {
+                try {
+                    const instance = getFinosESignInstance();
+                    const value = instance[prop];
+                    if (typeof value === 'function') {
+                        return value.bind(instance);
+                    }
+                    return value;
+                }
+                catch (error) {
+                    console.warn(`⚠️ FinosESign.${String(prop)} is not available:`, error);
+                    // Always return a function for methods to prevent "undefined" errors
+                    if (isMethod(prop)) {
+                        // For event listeners (on* methods), return a function that returns null
+                        if (typeof prop === 'string' && prop.startsWith('on')) {
+                            return (callback) => {
+                                console.warn(`⚠️ FinosESign.${prop} called but module is not initialized`);
+                                return null;
+                            };
+                        }
+                        // For other methods, return a no-op async function
+                        return async (...args) => {
+                            console.warn(`⚠️ FinosESign.${String(prop)} called but module is not initialized`);
+                            throw new Error(`FinosESign.${String(prop)} is not available. Module may not be initialized.`);
+                        };
+                    }
+                    return undefined;
+                }
+            }
+        });
+    }
+    catch (error) {
+        console.error('❌ Failed to create FinosESign proxy:', error);
+        // Return a comprehensive stub object
+        return createFinosESignStub();
+    }
+};
+// Create a comprehensive stub object with all methods to prevent undefined errors
+const createFinosESignStub = () => {
+    const stub = {};
+    // Add all event listener methods (on* methods)
+    const eventListenerMethods = [
+        'onSmsOtpSendSuccess', 'onSmsOtpVerifySuccess', 'onSmsOtpResendSuccess', 'onSmsOtpError',
+        'onESignInitSuccess', 'onESignOpenSessionSuccess', 'onESignRegisterDeviceSuccess',
+        'onESignListCertsSuccess', 'onESignVerifyCertSuccess', 'onESignListSignRequestSuccess',
+        'onESignConfirmSignSuccess', 'onESignAuthenticateSuccess', 'onESignRegisterRemoteSigningSuccess',
+        'onESignSignPdfSuccess', 'onESignSendConfirmationDocumentSuccess', 'onESignError',
+        'onLivenessSuccess', 'onLivenessError', 'onFaceCompareSuccess', 'onFaceCompareError'
+    ];
+    eventListenerMethods.forEach(method => {
+        stub[method] = (callback) => {
+            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'
+    ];
+    otherMethods.forEach(method => {
+        stub[method] = async (...args) => {
+            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;
+};
+// Create a wrapper that always returns a valid object
+// This ensures FinosESign is NEVER undefined and always has all methods
+const createFinosESignWrapper = () => {
+    // Always start with stub to ensure all methods exist
+    const stub = createFinosESignStub();
+    const wrapper = Object.assign({}, stub);
+    // 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[key] === 'function') {
+                wrapper[key] = (realInstance[key]).bind(realInstance);
+            }
+        });
+        // Also copy any own properties from real instance
+        Object.keys(realInstance).forEach(key => {
+            if (realInstance[key] !== undefined) {
+                wrapper[key] = realInstance[key];
+            }
+        });
+    }
+    catch (error) {
+        // If we can't get instance, wrapper already has all stub methods
+        // No need to do anything
+    }
+    return wrapper;
+};
+// Export - this ensures FinosESign is never undefined
+exports.FinosESign = createFinosESignWrapper();
+// Default export
+exports.default = exports.FinosESign;