@hexar/biometric-identity-sdk-core 1.0.0

package/dist/api/BackendClient.js

@@ -0,0 +1,199 @@
+"use strict";
+/**
+ * Backend API Client for Biometric Identity SDK
+ * Communicates with the Python backend for AI-powered validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendClient = void 0;
+/**
+ * Client for communicating with the Biometric Identity Backend
+ */
+class BackendClient {
+    constructor(config) {
+        this.currentSessionId = null;
+        this.config = {
+            apiEndpoint: config.apiEndpoint.replace(/\/$/, ''), // Remove trailing slash
+            apiKey: config.apiKey,
+            timeout: config.timeout || 60000,
+        };
+    }
+    /**
+     * Check if the backend is available
+     */
+    async healthCheck() {
+        try {
+            const response = await this.request('/api/v1/health', 'GET');
+            return response.status === 'healthy';
+        }
+        catch (error) {
+            console.warn('Backend health check failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Generate a liveness challenge
+     */
+    async generateChallenge(challengeType = 'active') {
+        const response = await this.request('/api/v1/liveness/challenge', 'POST', {
+            challenge_type: challengeType,
+            session_id: this.currentSessionId,
+        });
+        this.currentSessionId = response.session_id;
+        return response;
+    }
+    /**
+     * Validate liveness from video frames
+     */
+    async validateLiveness(videoFrames, videoDurationMs, challengesCompleted = [], deviceInfo) {
+        if (!this.currentSessionId) {
+            throw new Error('No active session. Call generateChallenge() first.');
+        }
+        const response = await this.request('/api/v1/liveness/validate', 'POST', {
+            session_id: this.currentSessionId,
+            video_frames: videoFrames,
+            video_duration_ms: videoDurationMs,
+            challenges_completed: challengesCompleted,
+            device_info: deviceInfo,
+        });
+        return response;
+    }
+    /**
+     * Compare faces between document and live capture
+     */
+    async matchFaces(documentImage, liveFaceImage) {
+        return this.request('/api/v1/face/match', 'POST', {
+            document_image: documentImage,
+            live_face_image: liveFaceImage,
+            session_id: this.currentSessionId,
+        });
+    }
+    /**
+     * Validate document and extract data
+     */
+    async validateDocument(frontImage, backImage, documentType, countryCode) {
+        return this.request('/api/v1/document/validate', 'POST', {
+            front_image: frontImage,
+            back_image: backImage,
+            document_type: documentType,
+            country_code: countryCode,
+        });
+    }
+    /**
+     * Perform full biometric validation
+     */
+    async fullValidation(params) {
+        if (!this.currentSessionId) {
+            // Generate a challenge first if no session exists
+            await this.generateChallenge();
+        }
+        return this.request('/api/v1/validate', 'POST', {
+            front_id_image: params.frontIdImage,
+            back_id_image: params.backIdImage,
+            video_frames: params.videoFrames,
+            video_duration_ms: params.videoDurationMs,
+            session_id: this.currentSessionId,
+            challenges_completed: params.challengesCompleted || [],
+            document_type: params.documentType,
+            country_code: params.countryCode,
+            device_info: params.deviceInfo,
+        });
+    }
+    /**
+     * Convert backend response to SDK ValidationResult format
+     */
+    convertToValidationResult(response) {
+        const extractedData = response.extracted_data;
+        return {
+            matchScore: response.match_score,
+            isValidFaceMatch: response.face_match_passed,
+            isDocumentAuthentic: response.document_authentic,
+            livenessScore: response.liveness_score * 100, // Convert 0-1 to 0-100
+            extractedDocumentData: {
+                firstName: extractedData.first_name || '',
+                lastName: extractedData.last_name || '',
+                documentNumber: extractedData.document_number || '',
+                dateOfBirth: extractedData.date_of_birth || '',
+                expirationDate: extractedData.expiration_date || '',
+                nationality: extractedData.nationality || '',
+                documentType: extractedData.document_type,
+                gender: extractedData.gender,
+                address: extractedData.address,
+                issuingCountry: extractedData.issuing_country,
+                rawText: extractedData.raw_text,
+            },
+            warnings: response.warnings,
+            timestamp: new Date(response.timestamp).getTime(),
+            details: {
+                faceDetection: {
+                    detected: response.details.face_match.live_face_detected,
+                    confidence: response.details.face_match.live_face_confidence,
+                },
+                documentQuality: {
+                    hasGlare: response.details.document.quality.has_glare,
+                    hasBlur: response.details.document.quality.has_blur,
+                    hasCropping: response.details.document.quality.has_cropping,
+                    hasReflections: response.details.document.quality.has_shadows,
+                    edgeDetectionScore: response.details.document.quality.edge_detection_score,
+                },
+                tamperDetection: {
+                    isTampered: response.details.document.tamper_detection.is_tampered,
+                    tamperScore: response.details.document.tamper_detection.tamper_score,
+                    suspiciousRegions: response.details.document.tamper_detection.suspicious_regions,
+                },
+                livenessChecks: {
+                    passedMotionCheck: response.details.liveness.checks.find(c => c.name === 'motion_analysis')?.passed || false,
+                    passedTextureCheck: response.details.liveness.checks.find(c => c.name === 'texture_analysis')?.passed || false,
+                    passedDepthCheck: response.details.liveness.checks.find(c => c.name === 'face_consistency')?.passed || false,
+                },
+            },
+        };
+    }
+    /**
+     * Get current session ID
+     */
+    getSessionId() {
+        return this.currentSessionId;
+    }
+    /**
+     * Reset session
+     */
+    resetSession() {
+        this.currentSessionId = null;
+    }
+    /**
+     * Make HTTP request to backend
+     */
+    async request(endpoint, method, body) {
+        const url = `${this.config.apiEndpoint}${endpoint}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-API-Key': this.config.apiKey,
+                },
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(errorData?.error?.message ||
+                    errorData?.detail ||
+                    `Request failed with status ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === 'AbortError') {
+                throw new Error('Request timeout');
+            }
+            throw error;
+        }
+    }
+}
+exports.BackendClient = BackendClient;
+exports.default = BackendClient;

package/dist/api/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * API Client exports
+ */
+export { BackendClient } from './BackendClient';
+export type { ChallengeAction, ChallengeResponse, LivenessResponse, FaceMatchResponse, DocumentValidationResponse, FullValidationResponse, BackendClientConfig, } from './BackendClient';

package/dist/api/index.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * API Client exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendClient = void 0;
+var BackendClient_1 = require("./BackendClient");
+Object.defineProperty(exports, "BackendClient", { enumerable: true, get: function () { return BackendClient_1.BackendClient; } });

package/dist/encryption/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Encryption utilities for secure data transmission
+ */
+import { EncryptedData } from '../types';
+export declare class EncryptionService {
+    private encryptionKey?;
+    private algorithm;
+    private keyLength;
+    constructor(encryptionKey?: string | undefined);
+    /**
+     * Encrypt data using AES-256-GCM
+     */
+    encrypt(data: string): Promise<EncryptedData>;
+    /**
+     * Decrypt data using AES-256-GCM
+     */
+    decrypt(encryptedData: EncryptedData): Promise<string>;
+    /**
+     * Encrypt image data (base64)
+     */
+    encryptImage(base64Image: string): Promise<EncryptedData>;
+    /**
+     * Hash data using SHA-256
+     */
+    hash(data: string): string;
+    /**
+     * Generate secure random token
+     */
+    generateToken(length?: number): string;
+}
+/**
+ * Encrypt multiple images for batch processing
+ */
+export declare function encryptImages(images: string[], encryptionKey?: string): Promise<EncryptedData[]>;
+/**
+ * Create integrity signature for data
+ */
+export declare function createIntegritySignature(data: any): string;

package/dist/encryption/index.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Encryption utilities for secure data transmission
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptionService = void 0;
+exports.encryptImages = encryptImages;
+exports.createIntegritySignature = createIntegritySignature;
+const crypto_1 = __importDefault(require("crypto"));
+class EncryptionService {
+    constructor(encryptionKey) {
+        this.encryptionKey = encryptionKey;
+        this.algorithm = 'aes-256-gcm';
+        this.keyLength = 32; // 256 bits
+        if (!encryptionKey) {
+            // Generate a random key if not provided
+            this.encryptionKey = crypto_1.default.randomBytes(this.keyLength).toString('hex');
+        }
+    }
+    /**
+     * Encrypt data using AES-256-GCM
+     */
+    async encrypt(data) {
+        try {
+            const key = Buffer.from(this.encryptionKey, 'hex').slice(0, this.keyLength);
+            const iv = crypto_1.default.randomBytes(16);
+            const cipher = crypto_1.default.createCipheriv(this.algorithm, key, iv);
+            let encrypted = cipher.update(data, 'utf8', 'base64');
+            encrypted += cipher.final('base64');
+            const authTag = cipher.getAuthTag();
+            return {
+                data: encrypted,
+                iv: iv.toString('base64'),
+                tag: authTag.toString('base64'),
+                algorithm: this.algorithm,
+            };
+        }
+        catch (error) {
+            throw new Error(`Encryption failed: ${error}`);
+        }
+    }
+    /**
+     * Decrypt data using AES-256-GCM
+     */
+    async decrypt(encryptedData) {
+        try {
+            const key = Buffer.from(this.encryptionKey, 'hex').slice(0, this.keyLength);
+            const iv = Buffer.from(encryptedData.iv, 'base64');
+            const authTag = Buffer.from(encryptedData.tag || '', 'base64');
+            const decipher = crypto_1.default.createDecipheriv(this.algorithm, key, iv);
+            decipher.setAuthTag(authTag);
+            let decrypted = decipher.update(encryptedData.data, 'base64', 'utf8');
+            decrypted += decipher.final('utf8');
+            return decrypted;
+        }
+        catch (error) {
+            throw new Error(`Decryption failed: ${error}`);
+        }
+    }
+    /**
+     * Encrypt image data (base64)
+     */
+    async encryptImage(base64Image) {
+        return this.encrypt(base64Image);
+    }
+    /**
+     * Hash data using SHA-256
+     */
+    hash(data) {
+        return crypto_1.default.createHash('sha256').update(data).digest('hex');
+    }
+    /**
+     * Generate secure random token
+     */
+    generateToken(length = 32) {
+        return crypto_1.default.randomBytes(length).toString('hex');
+    }
+}
+exports.EncryptionService = EncryptionService;
+/**
+ * Encrypt multiple images for batch processing
+ */
+async function encryptImages(images, encryptionKey) {
+    const service = new EncryptionService(encryptionKey);
+    return Promise.all(images.map(img => service.encryptImage(img)));
+}
+/**
+ * Create integrity signature for data
+ */
+function createIntegritySignature(data) {
+    const dataString = JSON.stringify(data);
+    return crypto_1.default
+        .createHmac('sha256', 'biometric-identity-sdk')
+        .update(dataString)
+        .digest('hex');
+}

package/dist/i18n/index.d.ts

@@ -0,0 +1,6 @@
+import { SupportedLanguage, LanguageStrings } from './types';
+export declare const setLanguage: (lang: SupportedLanguage) => void;
+export declare const getStrings: () => LanguageStrings;
+export declare const getCurrentLanguage: () => SupportedLanguage;
+export { SupportedLanguage, LanguageStrings };
+export * from './types';

package/dist/i18n/index.js

@@ -0,0 +1,47 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentLanguage = exports.getStrings = exports.setLanguage = void 0;
+const en_1 = require("./languages/en");
+const es_1 = require("./languages/es");
+const es_AR_1 = require("./languages/es-AR");
+const pt_BR_1 = require("./languages/pt-BR");
+const languages = {
+    'en': en_1.en,
+    'es': es_1.es,
+    'es-AR': es_AR_1.esAR,
+    'pt-BR': pt_BR_1.ptBR,
+};
+let currentLanguage = 'en';
+const setLanguage = (lang) => {
+    if (languages[lang]) {
+        currentLanguage = lang;
+    }
+    else {
+        console.warn(`Language ${lang} not supported, falling back to English`);
+        currentLanguage = 'en';
+    }
+};
+exports.setLanguage = setLanguage;
+const getStrings = () => {
+    return languages[currentLanguage];
+};
+exports.getStrings = getStrings;
+const getCurrentLanguage = () => {
+    return currentLanguage;
+};
+exports.getCurrentLanguage = getCurrentLanguage;
+__exportStar(require("./types"), exports);

package/dist/i18n/languages/en.d.ts

@@ -0,0 +1,2 @@
+import { LanguageStrings } from '../types';
+export declare const en: LanguageStrings;

package/dist/i18n/languages/en.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.en = void 0;
+exports.en = {
+    common: {
+        loading: 'Loading...',
+        error: 'Error',
+        retry: 'Retry',
+        cancel: 'Cancel',
+        continue: 'Continue',
+        close: 'Close',
+        done: 'Done',
+    },
+    initialization: {
+        initializing: 'Initializing...',
+        connectingToServer: 'Connecting to server...',
+        loadingModels: 'Loading AI models...',
+    },
+    instructions: {
+        title: 'Identity Verification',
+        subtitle: 'Follow these steps to verify your identity',
+        step1: 'Capture front of ID',
+        step2: 'Capture back of ID',
+        step3: 'Record face video',
+        startButton: 'Start Verification',
+        requirements: {
+            goodLighting: 'Good lighting',
+            clearDocument: 'Clear document',
+            stableHand: 'Stable hand',
+            followInstructions: 'Follow instructions',
+        },
+    },
+    capture: {
+        frontId: {
+            title: 'Front of ID',
+            instruction: 'Position the front of your ID within the frame',
+            button: 'Capture Front ID',
+        },
+        backId: {
+            title: 'Back of ID',
+            instruction: 'Position the back of your ID within the frame',
+            button: 'Capture Back ID',
+        },
+        selfie: {
+            title: 'Face Photo',
+            instruction: 'Position your face within the frame',
+            button: 'Take Photo',
+        },
+    },
+    liveness: {
+        title: 'Face Verification',
+        preparing: 'Preparing verification...',
+        instructions: {
+            lookLeft: 'Look to the left',
+            lookRight: 'Look to the right',
+            lookUp: 'Look up',
+            lookDown: 'Look down',
+            smile: 'Smile',
+            blink: 'Blink naturally',
+            turnHeadLeft: 'Turn your head to the left',
+            turnHeadRight: 'Turn your head to the right',
+            stayStill: 'Stay still',
+        },
+        recording: 'Recording...',
+        processing: 'Processing video...',
+    },
+    validation: {
+        title: 'Validating',
+        validating: 'Validating your identity...',
+        checkingDocument: 'Checking document authenticity...',
+        checkingLiveness: 'Verifying liveness...',
+        matchingFaces: 'Matching faces...',
+        almostDone: 'Almost done...',
+    },
+    result: {
+        success: {
+            title: 'Verification Successful',
+            message: 'Your identity has been verified successfully',
+            verificationComplete: 'Verification Complete',
+        },
+        failure: {
+            title: 'Verification Failed',
+            message: 'We could not verify your identity',
+            tryAgain: 'Please try again',
+        },
+    },
+    errors: {
+        cameraPermissionDenied: 'Camera permission denied. Please enable camera access in settings.',
+        cameraNotAvailable: 'Camera not available.',
+        faceNotDetected: 'Face not detected. Please position your face clearly.',
+        multipleFacesDetected: 'Multiple faces detected. Only one person should be in frame.',
+        documentNotDetected: 'Document not detected. Please position your ID clearly.',
+        poorImageQuality: 'Image quality too low. Please ensure good lighting.',
+        livenessCheckFailed: 'Liveness check failed. Please try again.',
+        faceMatchFailed: 'Face does not match document photo.',
+        documentTampered: 'Document appears to be tampered or fraudulent.',
+        networkError: 'Network error. Please check your connection.',
+        timeout: 'Request timeout. Please try again.',
+        unknownError: 'An unexpected error occurred.',
+    },
+    badges: {
+        secureVerification: 'Secure AI Verification',
+        aiPowered: 'AI-Powered',
+        verified: 'Verified',
+    },
+    steps: {
+        frontId: 'Front ID',
+        backId: 'Back ID',
+        faceVideo: 'Face Video',
+        validation: 'Validation',
+    },
+};

package/dist/i18n/languages/es-AR.d.ts

@@ -0,0 +1,2 @@
+import { LanguageStrings } from '../types';
+export declare const esAR: LanguageStrings;

package/dist/i18n/languages/es-AR.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.esAR = void 0;
+exports.esAR = {
+    common: {
+        loading: 'Cargando...',
+        error: 'Error',
+        retry: 'Reintentar',
+        cancel: 'Cancelar',
+        continue: 'Continuar',
+        close: 'Cerrar',
+        done: 'Listo',
+    },
+    initialization: {
+        initializing: 'Iniciando...',
+        connectingToServer: 'Conectando al servidor...',
+        loadingModels: 'Cargando modelos de IA...',
+    },
+    instructions: {
+        title: 'Verificación de Identidad',
+        subtitle: 'Seguí estos pasos para verificar tu identidad',
+        step1: 'Capturá el frente de tu documento',
+        step2: 'Capturá el dorso de tu documento',
+        step3: 'Grabá un video de tu rostro',
+        startButton: 'Iniciar Verificación',
+        requirements: {
+            goodLighting: 'Buena iluminación',
+            clearDocument: 'Documento claro',
+            stableHand: 'Mano firme',
+            followInstructions: 'Seguí las instrucciones',
+        },
+    },
+    capture: {
+        frontId: {
+            title: 'Frente del Documento',
+            instruction: 'Posicioná el frente de tu documento dentro del marco',
+            button: 'Capturar Frente',
+        },
+        backId: {
+            title: 'Dorso del Documento',
+            instruction: 'Posicioná el dorso de tu documento dentro del marco',
+            button: 'Capturar Dorso',
+        },
+        selfie: {
+            title: 'Foto de Rostro',
+            instruction: 'Posicioná tu rostro dentro del marco',
+            button: 'Tomar Foto',
+        },
+    },
+    liveness: {
+        title: 'Verificación Facial',
+        preparing: 'Preparando verificación...',
+        instructions: {
+            lookLeft: 'Mirá a la izquierda',
+            lookRight: 'Mirá a la derecha',
+            lookUp: 'Mirá hacia arriba',
+            lookDown: 'Mirá hacia abajo',
+            smile: 'Sonreí',
+            blink: 'Parpadeá naturalmente',
+            turnHeadLeft: 'Girá tu cabeza a la izquierda',
+            turnHeadRight: 'Girá tu cabeza a la derecha',
+            stayStill: 'Quedate quieto',
+        },
+        recording: 'Grabando...',
+        processing: 'Procesando video...',
+    },
+    validation: {
+        title: 'Validando',
+        validating: 'Validando tu identidad...',
+        checkingDocument: 'Verificando autenticidad del documento...',
+        checkingLiveness: 'Verificando prueba de vida...',
+        matchingFaces: 'Comparando rostros...',
+        almostDone: 'Ya casi terminamos...',
+    },
+    result: {
+        success: {
+            title: 'Verificación Exitosa',
+            message: 'Tu identidad fue verificada correctamente',
+            verificationComplete: 'Verificación Completa',
+        },
+        failure: {
+            title: 'Verificación Fallida',
+            message: 'No pudimos verificar tu identidad',
+            tryAgain: 'Por favor, intentá nuevamente',
+        },
+    },
+    errors: {
+        cameraPermissionDenied: 'Permiso de cámara denegado. Habilitá el acceso en configuración.',
+        cameraNotAvailable: 'Cámara no disponible.',
+        faceNotDetected: 'Rostro no detectado. Posicioná tu cara claramente.',
+        multipleFacesDetected: 'Múltiples rostros detectados. Solo debe haber una persona.',
+        documentNotDetected: 'Documento no detectado. Posicioná tu documento claramente.',
+        poorImageQuality: 'Calidad de imagen baja. Asegurate de tener buena iluminación.',
+        livenessCheckFailed: 'Prueba de vida fallida. Intentá nuevamente.',
+        faceMatchFailed: 'El rostro no coincide con la foto del documento.',
+        documentTampered: 'El documento parece estar alterado o ser fraudulento.',
+        networkError: 'Error de red. Verificá tu conexión.',
+        timeout: 'Tiempo de espera agotado. Intentá nuevamente.',
+        unknownError: 'Ocurrió un error inesperado.',
+    },
+    badges: {
+        secureVerification: 'Verificación Segura con IA',
+        aiPowered: 'Impulsado por IA',
+        verified: 'Verificado',
+    },
+    steps: {
+        frontId: 'Frente',
+        backId: 'Dorso',
+        faceVideo: 'Video',
+        validation: 'Validación',
+    },
+};

package/dist/i18n/languages/es.d.ts

@@ -0,0 +1,2 @@
+import { LanguageStrings } from '../types';
+export declare const es: LanguageStrings;