@finos_sdk/sdk-ekyc 1.2.2 → 1.2.9

package/src/modules/FinosESignModule.ts

@@ -0,0 +1,919 @@
+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 { LivenessConfig } from '../types/ekycLivenessType';
+import { FaceServiceConfig } from '../types/ekycFaceType';
+import { SDKEkycResultStringWithEvent, SDKEkycResultWithEvent } from '../types/ekycType';
+
+/**
+ * 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
+ */
+export class FinosESignModule {
+    private static instance: FinosESignModule;
+    private sdk: SDKeKYC;
+    private isInitialized: boolean = false;
+    private platform: string;
+
+    private constructor() {
+        this.sdk = sdkEKYC;
+        this.platform = Platform.OS;
+    }
+
+    /**
+     * Get singleton instance of FinosESignModule
+     */
+    public static getInstance(): FinosESignModule {
+        if (!FinosESignModule.instance) {
+            FinosESignModule.instance = new FinosESignModule();
+        }
+        return FinosESignModule.instance;
+    }
+
+    /**
+     * Get SDK information
+     */
+    public async getSDKInfo(): Promise<{
+        name: string;
+        version: string;
+        buildNumber: string;
+        platform: string;
+        isInitialized: boolean;
+    }> {
+        try {
+            const nativeInfo = await this.sdk.getSDKInfo();
+            return {
+                ...nativeInfo,
+                platform: this.platform,
+                isInitialized: this.isInitialized
+            };
+        } catch (error) {
+            return {
+                name: SDK_NAME,
+                version: SDK_VERSION,
+                buildNumber: '1',
+                platform: this.platform,
+                isInitialized: this.isInitialized
+            };
+        }
+    }
+
+    /**
+     * Initialize the eSign SDK
+     * Must be called before using any other methods
+     */
+    public async initialize(): Promise<string> {
+        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${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
+     */
+    public isSDKReady(): boolean {
+        return this.isInitialized && this.sdk.isSDKInitialized();
+    }
+
+    // ==================== SMS OTP Methods ====================
+
+    /**
+     * Send SMS OTP
+     * @param config SMS OTP configuration
+     */
+    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;
+        }
+    }
+
+    /**
+     * Verify SMS OTP
+     * @param config SMS OTP configuration (must include requestId)
+     * @param otpCode OTP code from SMS
+     */
+    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;
+        }
+    }
+
+    /**
+     * Resend SMS OTP
+     * @param config SMS OTP configuration (must include requestId)
+     */
+    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;
+        }
+    }
+
+    // SMS OTP Event Listeners
+    public onSmsOtpSendSuccess(callback: (data: SmsOtpResult) => void) {
+        const listener = this.sdk.onSmsOtpSendSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpSendSuccess: Event emitter not ready. Make sure SDK is initialized.');
+        }
+        return listener;
+    }
+
+    public onSmsOtpVerifySuccess(callback: (data: SmsOtpResult) => void) {
+        const listener = this.sdk.onSmsOtpVerifySuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpVerifySuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onSmsOtpResendSuccess(callback: (data: SmsOtpResult) => void) {
+        const listener = this.sdk.onSmsOtpResendSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpResendSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onSmsOtpError(callback: (error: SmsOtpError) => void) {
+        const listener = this.sdk.onSmsOtpError(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpError: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    // ==================== eSign Methods ====================
+
+    /**
+     * Initialize eSign SDK
+     */
+    public async initializeESign(): 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;
+        }
+    }
+
+    /**
+     * 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)
+     */
+    public async openSessionId(
+        accessToken?: string,
+        username?: string,
+        rememberMe?: boolean,
+        userEsignModel?: UserEsignModel,
+        privateKeyFilePath?: string
+    ): 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;
+        }
+    }
+
+    /**
+     * Register device for eSign
+     * @param recoverCode 8-digit recovery code
+     * @param pinCode 6-digit PIN code
+     * @param fcmToken Optional FCM token
+     */
+    public async registerDevice(
+        recoverCode: string,
+        pinCode: string,
+        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;
+        }
+    }
+
+    /**
+     * List eSign certificates
+     * @param pageNumber Page number (default: 1)
+     * @param pageSize Page size (default: 10)
+     */
+    public async listCerts(
+        pageNumber: number = 1,
+        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;
+        }
+    }
+
+    /**
+     * Verify eSign certificate
+     * @param serial Certificate serial number
+     */
+    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;
+        }
+    }
+
+    /**
+     * List eSign sign requests
+     * @param pageNumber Page number (default: 1)
+     * @param pageSize Page size (default: 10)
+     */
+    public async listSignRequest(
+        pageNumber: number = 1,
+        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;
+        }
+    }
+
+    /**
+     * 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)
+     */
+    public async confirmSign(
+        signRequestId: string,
+        pinCode: string,
+        authId?: string,
+        authData?: string,
+        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;
+        }
+    }
+
+    /**
+     * 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;
+        }
+    }
+
+    /**
+     * 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;
+        }
+    }
+
+    /**
+     * 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;
+        }
+    }
+
+    /**
+     * Remove all event listeners
+     */
+    public removeAllListeners(): void {
+        this.sdk.removeAllListeners();
+        console.log('🧹 All event listeners removed');
+    }
+
+    // eSign Event Listeners
+    public onESignInitSuccess(callback: (data: ESignInitResult) => void) {
+        const listener = this.sdk.onESignInitSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignInitSuccess: Event emitter not ready. Make sure SDK is initialized.');
+        }
+        return listener;
+    }
+
+    public onESignOpenSessionSuccess(callback: (data: ESignOpenSessionResult) => void) {
+        const listener = this.sdk.onESignOpenSessionSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignOpenSessionSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onESignRegisterDeviceSuccess(callback: (data: { code: string; message: string }) => void) {
+        const listener = this.sdk.onESignRegisterDeviceSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignRegisterDeviceSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onESignListCertsSuccess(callback: (data: { certs: ESignCertificate[] }) => void) {
+        const listener = this.sdk.onESignListCertsSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignListCertsSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onESignVerifyCertSuccess(callback: (data: { code: string; message: string }) => void) {
+        const listener = this.sdk.onESignVerifyCertSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignVerifyCertSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onESignListSignRequestSuccess(callback: (data: { requests: ESignSignRequest[] }) => void) {
+        const listener = this.sdk.onESignListSignRequestSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignListSignRequestSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onESignConfirmSignSuccess(callback: (data: { code: string; message: string }) => void) {
+        const listener = this.sdk.onESignConfirmSignSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignConfirmSignSuccess: Event emitter not ready.');
+        }
+        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);
+        if (!listener) {
+            console.warn('⚠️ onESignRegisterRemoteSigningSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onESignSignPdfSuccess(callback: (data: { response: string }) => void) {
+        const listener = this.sdk.onESignSignPdfSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignSignPdfSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onESignSendConfirmationDocumentSuccess(callback: (data: { response: string }) => void) {
+        const listener = this.sdk.onESignSendConfirmationDocumentSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onESignSendConfirmationDocumentSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onESignError(callback: (error: ESignError) => void) {
+        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)
+     */
+    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;
+        }
+    }
+
+    // Liveness Event Listeners
+    public onLivenessSuccess(callback: (data: SDKEkycResultStringWithEvent) => void) {
+        return this.sdk.onLivenessSuccess(callback);
+    }
+
+    public onLivenessError(callback: (error: any) => void) {
+        return this.sdk.onLivenessError(callback);
+    }
+
+    // ==================== Face Service Methods ====================
+
+    /**
+     * Start face comparison
+     * @param config Face service configuration
+     */
+    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;
+        }
+    }
+
+    // Face Compare Event Listeners
+    public onFaceCompareSuccess(callback: (data: SDKEkycResultWithEvent) => void) {
+        return this.sdk.onFaceCompareSuccess(callback);
+    }
+
+    public onFaceCompareError(callback: (error: any) => void) {
+        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
+     */
+    public async startEkycUI(
+        appKey: string,
+        flowSDK: string[],
+        language: string,
+        transactionId: string,
+        appKeyConfig: {
+            appKey: string;
+            appKeyLiveness: string;
+            appKeyFaceService: string;
+        },
+        optionConfig?: {
+            baseUrl?: string;
+            countMaxRetry?: number;
+            language?: string;
+            switchFrontCamera?: boolean;
+        },
+        styleConfig?: {
+            textSize?: number;
+            textFont?: string;
+            textColor?: number;
+            statusBarBackground?: number;
+            backIcon?: number;
+            titleStyle?: {
+                textSize?: number;
+                textFont?: string;
+                textColor?: number;
+            };
+            toolbarStyle?: {
+                textSize?: number;
+                textFont?: string;
+                textColor?: number;
+            };
+            instructionStyle?: {
+                textSize?: number;
+                textFont?: string;
+                textColor?: number;
+            };
+            errorStyle?: {
+                textSize?: number;
+                textFont?: string;
+                textColor?: number;
+            };
+            successStyle?: {
+                textSize?: number;
+                textFont?: string;
+                textColor?: number;
+            };
+            warningStyle?: {
+                textSize?: number;
+                textFont?: string;
+                textColor?: number;
+            };
+        }
+    ): Promise<any> {
+        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?.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
+    private validateSDKReady(): void {
+        if (!this.isSDKReady()) {
+            throw new Error('SDK is not initialized. Please call initialize() first.');
+        }
+    }
+}
+
+// Export singleton instance - ensure it's always initialized
+let _finosESignInstance: FinosESignModule | null = null;
+
+const getFinosESignInstance = (): FinosESignModule => {
+    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: 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';
+};
+
+// Create a safe wrapper using Proxy - ensure it's always an object
+const createFinosESignProxy = (): FinosESignModule => {
+    try {
+        return new Proxy({} as FinosESignModule, {
+            get(_target, prop) {
+                try {
+                    const instance = getFinosESignInstance();
+                    const value = (instance as any)[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?: any) => {
+                                console.warn(`⚠️ FinosESign.${prop} called but module is not initialized`);
+                                return null;
+                            };
+                        }
+                        // For other methods, return a no-op async function
+                        return async (...args: any[]) => {
+                            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 = (): 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',
+        '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'
+    ];
+    
+    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;
+};
+
+// Create a wrapper that always returns a valid object
+// This ensures FinosESign is NEVER undefined and always has all methods
+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) {
+                wrapper[key] = (realInstance as any)[key];
+            }
+        });
+    } catch (error) {
+        // If we can't get instance, wrapper already has all stub methods
+        // No need to do anything
+    }
+    
+    return wrapper as FinosESignModule;
+};
+
+// Export - this ensures FinosESign is never undefined
+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 { LivenessConfig } from '../types/ekycLivenessType';
+export type { FaceServiceConfig } from '../types/ekycFaceType';
+export type { SDKEkycResultStringWithEvent, SDKEkycResultWithEvent } from '../types/ekycType';
+
+// Export constants
+export { SDK_VERSION, SDK_NAME };
+
+// Default export
+export default FinosESign;