@hexar/biometric-identity-sdk-core 1.0.0

package/dist/i18n/languages/es.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.es = void 0;
+exports.es = {
+    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: 'Sigue estos pasos para verificar tu identidad',
+        step1: 'Captura el frente de tu documento',
+        step2: 'Captura el reverso de tu documento',
+        step3: 'Graba un video de tu rostro',
+        startButton: 'Iniciar Verificación',
+        requirements: {
+            goodLighting: 'Buena iluminación',
+            clearDocument: 'Documento claro',
+            stableHand: 'Mano estable',
+            followInstructions: 'Sigue las instrucciones',
+        },
+    },
+    capture: {
+        frontId: {
+            title: 'Frente del Documento',
+            instruction: 'Posiciona el frente de tu documento dentro del marco',
+            button: 'Capturar Frente',
+        },
+        backId: {
+            title: 'Reverso del Documento',
+            instruction: 'Posiciona el reverso de tu documento dentro del marco',
+            button: 'Capturar Reverso',
+        },
+        selfie: {
+            title: 'Foto de Rostro',
+            instruction: 'Posiciona tu rostro dentro del marco',
+            button: 'Tomar Foto',
+        },
+    },
+    liveness: {
+        title: 'Verificación Facial',
+        preparing: 'Preparando verificación...',
+        instructions: {
+            lookLeft: 'Mira a la izquierda',
+            lookRight: 'Mira a la derecha',
+            lookUp: 'Mira hacia arriba',
+            lookDown: 'Mira hacia abajo',
+            smile: 'Sonríe',
+            blink: 'Parpadea naturalmente',
+            turnHeadLeft: 'Gira tu cabeza a la izquierda',
+            turnHeadRight: 'Gira tu cabeza a la derecha',
+            stayStill: 'Permanece 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: 'Casi terminamos...',
+    },
+    result: {
+        success: {
+            title: 'Verificación Exitosa',
+            message: 'Tu identidad ha sido verificada correctamente',
+            verificationComplete: 'Verificación Completa',
+        },
+        failure: {
+            title: 'Verificación Fallida',
+            message: 'No pudimos verificar tu identidad',
+            tryAgain: 'Por favor, intenta nuevamente',
+        },
+    },
+    errors: {
+        cameraPermissionDenied: 'Permiso de cámara denegado. Habilita el acceso en configuración.',
+        cameraNotAvailable: 'Cámara no disponible.',
+        faceNotDetected: 'Rostro no detectado. Posiciona tu cara claramente.',
+        multipleFacesDetected: 'Múltiples rostros detectados. Solo debe haber una persona.',
+        documentNotDetected: 'Documento no detectado. Posiciona tu documento claramente.',
+        poorImageQuality: 'Calidad de imagen baja. Asegura buena iluminación.',
+        livenessCheckFailed: 'Prueba de vida fallida. Intenta nuevamente.',
+        faceMatchFailed: 'El rostro no coincide con la foto del documento.',
+        documentTampered: 'El documento parece estar alterado o ser fraudulento.',
+        networkError: 'Error de red. Verifica tu conexión.',
+        timeout: 'Tiempo de espera agotado. Intenta nuevamente.',
+        unknownError: 'Ocurrió un error inesperado.',
+    },
+    badges: {
+        secureVerification: 'Verificación Segura con IA',
+        aiPowered: 'Impulsado por IA',
+        verified: 'Verificado',
+    },
+    steps: {
+        frontId: 'Frente',
+        backId: 'Reverso',
+        faceVideo: 'Video',
+        validation: 'Validación',
+    },
+};

package/dist/i18n/languages/pt-BR.d.ts

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

package/dist/i18n/languages/pt-BR.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ptBR = void 0;
+exports.ptBR = {
+    common: {
+        loading: 'Carregando...',
+        error: 'Erro',
+        retry: 'Tentar Novamente',
+        cancel: 'Cancelar',
+        continue: 'Continuar',
+        close: 'Fechar',
+        done: 'Pronto',
+    },
+    initialization: {
+        initializing: 'Inicializando...',
+        connectingToServer: 'Conectando ao servidor...',
+        loadingModels: 'Carregando modelos de IA...',
+    },
+    instructions: {
+        title: 'Verificação de Identidade',
+        subtitle: 'Siga estes passos para verificar sua identidade',
+        step1: 'Capture a frente do documento',
+        step2: 'Capture o verso do documento',
+        step3: 'Grave um vídeo do seu rosto',
+        startButton: 'Iniciar Verificação',
+        requirements: {
+            goodLighting: 'Boa iluminação',
+            clearDocument: 'Documento claro',
+            stableHand: 'Mão estável',
+            followInstructions: 'Siga as instruções',
+        },
+    },
+    capture: {
+        frontId: {
+            title: 'Frente do Documento',
+            instruction: 'Posicione a frente do seu documento dentro da moldura',
+            button: 'Capturar Frente',
+        },
+        backId: {
+            title: 'Verso do Documento',
+            instruction: 'Posicione o verso do seu documento dentro da moldura',
+            button: 'Capturar Verso',
+        },
+        selfie: {
+            title: 'Foto do Rosto',
+            instruction: 'Posicione seu rosto dentro da moldura',
+            button: 'Tirar Foto',
+        },
+    },
+    liveness: {
+        title: 'Verificação Facial',
+        preparing: 'Preparando verificação...',
+        instructions: {
+            lookLeft: 'Olhe para a esquerda',
+            lookRight: 'Olhe para a direita',
+            lookUp: 'Olhe para cima',
+            lookDown: 'Olhe para baixo',
+            smile: 'Sorria',
+            blink: 'Pisque naturalmente',
+            turnHeadLeft: 'Vire sua cabeça para a esquerda',
+            turnHeadRight: 'Vire sua cabeça para a direita',
+            stayStill: 'Fique parado',
+        },
+        recording: 'Gravando...',
+        processing: 'Processando vídeo...',
+    },
+    validation: {
+        title: 'Validando',
+        validating: 'Validando sua identidade...',
+        checkingDocument: 'Verificando autenticidade do documento...',
+        checkingLiveness: 'Verificando prova de vida...',
+        matchingFaces: 'Comparando rostos...',
+        almostDone: 'Quase pronto...',
+    },
+    result: {
+        success: {
+            title: 'Verificação Bem-Sucedida',
+            message: 'Sua identidade foi verificada com sucesso',
+            verificationComplete: 'Verificação Completa',
+        },
+        failure: {
+            title: 'Verificação Falhou',
+            message: 'Não conseguimos verificar sua identidade',
+            tryAgain: 'Por favor, tente novamente',
+        },
+    },
+    errors: {
+        cameraPermissionDenied: 'Permissão de câmera negada. Habilite o acesso nas configurações.',
+        cameraNotAvailable: 'Câmera não disponível.',
+        faceNotDetected: 'Rosto não detectado. Posicione seu rosto claramente.',
+        multipleFacesDetected: 'Múltiplos rostos detectados. Apenas uma pessoa deve estar no quadro.',
+        documentNotDetected: 'Documento não detectado. Posicione seu documento claramente.',
+        poorImageQuality: 'Qualidade de imagem baixa. Certifique-se de ter boa iluminação.',
+        livenessCheckFailed: 'Prova de vida falhou. Tente novamente.',
+        faceMatchFailed: 'O rosto não corresponde à foto do documento.',
+        documentTampered: 'O documento parece estar adulterado ou fraudulento.',
+        networkError: 'Erro de rede. Verifique sua conexão.',
+        timeout: 'Tempo esgotado. Tente novamente.',
+        unknownError: 'Ocorreu um erro inesperado.',
+    },
+    badges: {
+        secureVerification: 'Verificação Segura com IA',
+        aiPowered: 'Impulsionado por IA',
+        verified: 'Verificado',
+    },
+    steps: {
+        frontId: 'Frente',
+        backId: 'Verso',
+        faceVideo: 'Vídeo',
+        validation: 'Validação',
+    },
+};

package/dist/i18n/types.d.ts

@@ -0,0 +1,110 @@
+export type SupportedLanguage = 'en' | 'es' | 'es-AR' | 'pt-BR';
+export interface LanguageStrings {
+    common: {
+        loading: string;
+        error: string;
+        retry: string;
+        cancel: string;
+        continue: string;
+        close: string;
+        done: string;
+    };
+    initialization: {
+        initializing: string;
+        connectingToServer: string;
+        loadingModels: string;
+    };
+    instructions: {
+        title: string;
+        subtitle: string;
+        step1: string;
+        step2: string;
+        step3: string;
+        startButton: string;
+        requirements: {
+            goodLighting: string;
+            clearDocument: string;
+            stableHand: string;
+            followInstructions: string;
+        };
+    };
+    capture: {
+        frontId: {
+            title: string;
+            instruction: string;
+            button: string;
+        };
+        backId: {
+            title: string;
+            instruction: string;
+            button: string;
+        };
+        selfie: {
+            title: string;
+            instruction: string;
+            button: string;
+        };
+    };
+    liveness: {
+        title: string;
+        preparing: string;
+        instructions: {
+            lookLeft: string;
+            lookRight: string;
+            lookUp: string;
+            lookDown: string;
+            smile: string;
+            blink: string;
+            turnHeadLeft: string;
+            turnHeadRight: string;
+            stayStill: string;
+        };
+        recording: string;
+        processing: string;
+    };
+    validation: {
+        title: string;
+        validating: string;
+        checkingDocument: string;
+        checkingLiveness: string;
+        matchingFaces: string;
+        almostDone: string;
+    };
+    result: {
+        success: {
+            title: string;
+            message: string;
+            verificationComplete: string;
+        };
+        failure: {
+            title: string;
+            message: string;
+            tryAgain: string;
+        };
+    };
+    errors: {
+        cameraPermissionDenied: string;
+        cameraNotAvailable: string;
+        faceNotDetected: string;
+        multipleFacesDetected: string;
+        documentNotDetected: string;
+        poorImageQuality: string;
+        livenessCheckFailed: string;
+        faceMatchFailed: string;
+        documentTampered: string;
+        networkError: string;
+        timeout: string;
+        unknownError: string;
+    };
+    badges: {
+        secureVerification: string;
+        aiPowered: string;
+        verified: string;
+    };
+    steps: {
+        frontId: string;
+        backId: string;
+        faceVideo: string;
+        validation: string;
+    };
+}

package/dist/i18n/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Biometric Identity SDK - Core Package
+ * Main entry point for the SDK
+ */
+export { BiometricIdentitySDK } from './BiometricIdentitySDK';
+export { default } from './BiometricIdentitySDK';
+export * from './types';
+export { FaceDetector, calculateFaceSimilarity, calculateFaceDistance } from './ai-models/FaceDetector';
+export { LivenessDetector } from './ai-models/LivenessDetector';
+export { DocumentValidator, meetsQualityStandards } from './validation/DocumentValidator';
+export { OCREngine, cleanText, isValidDate } from './validation/OCREngine';
+export { EncryptionService, encryptImages, createIntegritySignature } from './encryption';
+export { BackendClient } from './api/BackendClient';
+export type { ChallengeAction, ChallengeResponse, LivenessResponse as BackendLivenessResponse, FaceMatchResponse, DocumentValidationResponse as BackendDocumentResponse, FullValidationResponse, BackendClientConfig, } from './api/BackendClient';
+export { BackendValidationService } from './services/BackendValidationService';
+export type { BackendValidationServiceConfig } from './services/BackendValidationService';
+export type { IValidationService, LivenessChallenge, DocumentValidationResult, LivenessResult, FaceMatchResult, } from './services/IValidationService';
+export { getStrings, setLanguage, getCurrentLanguage } from './i18n';
+export type { SupportedLanguage, LanguageStrings } from './i18n';
+export declare const SDK_VERSION = "1.0.0";

package/dist/index.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Biometric Identity SDK - Core Package
+ * Main entry point for the SDK
+ */
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = exports.getCurrentLanguage = exports.setLanguage = exports.getStrings = exports.BackendValidationService = exports.BackendClient = exports.createIntegritySignature = exports.encryptImages = exports.EncryptionService = exports.isValidDate = exports.cleanText = exports.OCREngine = exports.meetsQualityStandards = exports.DocumentValidator = exports.LivenessDetector = exports.calculateFaceDistance = exports.calculateFaceSimilarity = exports.FaceDetector = exports.default = exports.BiometricIdentitySDK = void 0;
+// Main SDK class
+var BiometricIdentitySDK_1 = require("./BiometricIdentitySDK");
+Object.defineProperty(exports, "BiometricIdentitySDK", { enumerable: true, get: function () { return BiometricIdentitySDK_1.BiometricIdentitySDK; } });
+var BiometricIdentitySDK_2 = require("./BiometricIdentitySDK");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(BiometricIdentitySDK_2).default; } });
+// Type definitions
+__exportStar(require("./types"), exports);
+// AI Models
+var FaceDetector_1 = require("./ai-models/FaceDetector");
+Object.defineProperty(exports, "FaceDetector", { enumerable: true, get: function () { return FaceDetector_1.FaceDetector; } });
+Object.defineProperty(exports, "calculateFaceSimilarity", { enumerable: true, get: function () { return FaceDetector_1.calculateFaceSimilarity; } });
+Object.defineProperty(exports, "calculateFaceDistance", { enumerable: true, get: function () { return FaceDetector_1.calculateFaceDistance; } });
+var LivenessDetector_1 = require("./ai-models/LivenessDetector");
+Object.defineProperty(exports, "LivenessDetector", { enumerable: true, get: function () { return LivenessDetector_1.LivenessDetector; } });
+// Validation
+var DocumentValidator_1 = require("./validation/DocumentValidator");
+Object.defineProperty(exports, "DocumentValidator", { enumerable: true, get: function () { return DocumentValidator_1.DocumentValidator; } });
+Object.defineProperty(exports, "meetsQualityStandards", { enumerable: true, get: function () { return DocumentValidator_1.meetsQualityStandards; } });
+var OCREngine_1 = require("./validation/OCREngine");
+Object.defineProperty(exports, "OCREngine", { enumerable: true, get: function () { return OCREngine_1.OCREngine; } });
+Object.defineProperty(exports, "cleanText", { enumerable: true, get: function () { return OCREngine_1.cleanText; } });
+Object.defineProperty(exports, "isValidDate", { enumerable: true, get: function () { return OCREngine_1.isValidDate; } });
+// Encryption
+var encryption_1 = require("./encryption");
+Object.defineProperty(exports, "EncryptionService", { enumerable: true, get: function () { return encryption_1.EncryptionService; } });
+Object.defineProperty(exports, "encryptImages", { enumerable: true, get: function () { return encryption_1.encryptImages; } });
+Object.defineProperty(exports, "createIntegritySignature", { enumerable: true, get: function () { return encryption_1.createIntegritySignature; } });
+// Backend API Client
+var BackendClient_1 = require("./api/BackendClient");
+Object.defineProperty(exports, "BackendClient", { enumerable: true, get: function () { return BackendClient_1.BackendClient; } });
+// Validation Services (Clean Architecture)
+var BackendValidationService_1 = require("./services/BackendValidationService");
+Object.defineProperty(exports, "BackendValidationService", { enumerable: true, get: function () { return BackendValidationService_1.BackendValidationService; } });
+// Internationalization
+var i18n_1 = require("./i18n");
+Object.defineProperty(exports, "getStrings", { enumerable: true, get: function () { return i18n_1.getStrings; } });
+Object.defineProperty(exports, "setLanguage", { enumerable: true, get: function () { return i18n_1.setLanguage; } });
+Object.defineProperty(exports, "getCurrentLanguage", { enumerable: true, get: function () { return i18n_1.getCurrentLanguage; } });
+// Version
+exports.SDK_VERSION = '1.0.0';

package/dist/services/BackendValidationService.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Backend Validation Service
+ *
+ * Implements IValidationService using the Python backend API.
+ * This is the recommended service for production use.
+ *
+ * SOLID Principles Applied:
+ * - Single Responsibility: Only handles backend API communication
+ * - Open/Closed: Implements interface, can be extended without modification
+ * - Liskov Substitution: Can replace any IValidationService implementation
+ * - Interface Segregation: Uses focused IValidationService interface
+ * - Dependency Inversion: Depends on abstractions (IValidationService)
+ */
+import { IValidationService, LivenessChallenge, DocumentValidationResult, LivenessResult, FaceMatchResult } from './IValidationService';
+import { ValidationResult } from '../types';
+export interface BackendValidationServiceConfig {
+    apiEndpoint: string;
+    apiKey: string;
+    timeout?: number;
+}
+export declare class BackendValidationService implements IValidationService {
+    private client;
+    private _isAvailable;
+    constructor(config: BackendValidationServiceConfig);
+    /**
+     * Check if backend is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Generate liveness challenge from backend
+     *
+     * API Endpoint: POST /api/v1/liveness/challenge
+     */
+    generateLivenessChallenge(type: 'active' | 'passive'): Promise<LivenessChallenge>;
+    /**
+     * Validate document using backend
+     *
+     * API Endpoint: POST /api/v1/document/validate
+     */
+    validateDocument(frontImage: string, backImage?: string, options?: {
+        documentType?: string;
+        countryCode?: string;
+    }): Promise<DocumentValidationResult>;
+    /**
+     * Validate liveness from video frames
+     *
+     * API Endpoint: POST /api/v1/liveness/validate
+     */
+    validateLiveness(sessionId: string, videoFrames: string[], videoDurationMs: number, challengesCompleted: string[]): Promise<LivenessResult>;
+    /**
+     * Compare faces between document and live capture
+     *
+     * API Endpoint: POST /api/v1/face/match
+     */
+    matchFaces(documentImage: string, liveImage: string): Promise<FaceMatchResult>;
+    /**
+     * Perform full biometric validation
+     *
+     * API Endpoint: POST /api/v1/validate
+     *
+     * This is the main validation endpoint that combines:
+     * 1. Document validation
+     * 2. Liveness detection
+     * 3. Face matching
+     */
+    fullValidation(params: {
+        frontIdImage: string;
+        backIdImage?: string;
+        videoFrames: string[];
+        videoDurationMs: number;
+        sessionId: string;
+        challengesCompleted: string[];
+        documentType?: string;
+        countryCode?: string;
+    }): Promise<ValidationResult>;
+    /**
+     * Get current session ID
+     */
+    getSessionId(): string | null;
+    /**
+     * Reset session
+     */
+    resetSession(): void;
+}