@giouwur/biometric-sdk 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,569 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default from 'react';
+import * as zustand from 'zustand';
+import * as axios from 'axios';
+
+interface BiometricConfig {
+    /** WebSocket URL for the biometric device server */
+    wsUrl: string;
+    /** Optional API base URL — exposed via useBiometricConfig() for the consuming app */
+    apiBaseUrl?: string;
+    /** Device identifier */
+    deviceId?: string;
+}
+/**
+ * Hook to access the SDK configuration from any child component.
+ *
+ * @example
+ * ```tsx
+ * const { apiBaseUrl } = useBiometricConfig();
+ * const res = await fetch(`${apiBaseUrl}/applicant/${id}`);
+ * ```
+ */
+declare function useBiometricConfig(): BiometricConfig;
+/**
+ * Provider that initializes and configures the Biometric SDK.
+ * Wrap your application (or the section that uses biometric components) with this provider.
+ *
+ * @example
+ * ```tsx
+ * import { BiometricProvider } from '@intell/biometric-sdk';
+ *
+ * export default function Layout({ children }) {
+ *   return (
+ *     <BiometricProvider config={{
+ *       wsUrl: "ws://localhost:5000/biometric",
+ *       apiBaseUrl: "http://localhost:8080/api/v1",
+ *       deviceId: "scanner_01"
+ *     }}>
+ *       {children}
+ *     </BiometricProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function BiometricProvider({ config, children, }: {
+    config: BiometricConfig;
+    children: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function FingerEnrollModule({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare function FaceEnrollModule({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare function PalmEnrollModule({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare function IrisEnrollModule({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare function FingerRollEnrollModule({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+interface FingerCaptureModalProps {
+    isOpen: boolean;
+    onCancel: () => void;
+    captureType: string;
+    previewImage: string | null;
+    previewQuality: number | null;
+}
+declare function FingerCaptureModal({ isOpen, onCancel, captureType, previewImage, previewQuality, }: FingerCaptureModalProps): react_jsx_runtime.JSX.Element;
+
+interface FingerRollCaptureModalProps {
+    isOpen: boolean;
+    onCancel: () => void;
+    captureType: string;
+    previewImage: string | null;
+    previewQuality: number | null;
+    rollStatus: string;
+}
+declare function FingerRollCaptureModal({ isOpen, onCancel, captureType, previewImage, previewQuality, rollStatus, }: FingerRollCaptureModalProps): react_jsx_runtime.JSX.Element;
+
+interface FaceCameraModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onCaptured: (img: string, quality: number) => void;
+}
+declare function FaceCameraModal({ isOpen, onClose, onCaptured, }: FaceCameraModalProps): react_jsx_runtime.JSX.Element;
+
+interface PalmCaptureModalProps {
+    isOpen: boolean;
+    onCancel: () => void;
+    onRetry: () => void;
+    captureType: string;
+    previewImage: string | null;
+    statusMessage: string;
+    errorState: boolean;
+}
+declare function PalmCaptureModal({ isOpen, onCancel, onRetry, captureType, previewImage, statusMessage, errorState, }: PalmCaptureModalProps): react_jsx_runtime.JSX.Element;
+
+interface IrisCameraModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onStartCapture: () => void;
+    onAbortCapture: () => void;
+    isCapturing: boolean;
+    statusMessage: string;
+    previewRight: string | null;
+    previewLeft: string | null;
+    distance: number | null;
+    cameraStatus: string;
+}
+declare function IrisCameraModal({ isOpen, onClose, onStartCapture, onAbortCapture, isCapturing, statusMessage, previewRight, previewLeft, distance, cameraStatus, }: IrisCameraModalProps): react_jsx_runtime.JSX.Element;
+
+interface ModuleHeaderProps {
+    icon: React__default.ReactNode;
+    title: string;
+    subtitle: string;
+    progress?: {
+        current: number;
+        total: number;
+    };
+    children?: React__default.ReactNode;
+}
+declare function ModuleHeader({ icon, title, subtitle, progress, children, }: ModuleHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'ghost';
+    size?: 'sm' | 'md' | 'lg';
+    isLoading?: boolean;
+    icon?: React__default.ReactNode;
+    children: React__default.ReactNode;
+}
+declare function Button({ variant, size, isLoading, icon, className, children, disabled, ...props }: ButtonProps): react_jsx_runtime.JSX.Element;
+
+interface CardProps {
+    variant?: 'subtle' | 'default' | 'medium' | 'strong' | 'modal' | 'glass' | 'glass-subtle' | 'glass-strong' | 'outlined';
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+    rounded?: 'lg' | 'xl' | '2xl' | '3xl';
+    className?: string;
+    children: React__default.ReactNode;
+}
+declare function Card({ variant, padding, rounded, className, children }: CardProps): react_jsx_runtime.JSX.Element;
+
+interface InputProps extends React__default.InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+    icon?: React__default.ReactNode;
+    error?: string;
+}
+declare function Input({ label, icon, error, className, ...props }: InputProps): react_jsx_runtime.JSX.Element;
+
+interface SelectOption {
+    value: string;
+    label: string;
+    icon?: React.ReactNode;
+}
+interface SelectProps {
+    value: string;
+    onChange: (value: string) => void;
+    options: SelectOption[];
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare function Select({ value, onChange, options, placeholder, disabled, className, }: SelectProps): react_jsx_runtime.JSX.Element;
+
+interface StatusChipProps {
+    status: 'success' | 'warning' | 'danger' | 'info' | 'neutral';
+    label: string;
+    icon?: React__default.ReactNode;
+    isLoading?: boolean;
+    size?: 'sm' | 'md';
+    showDot?: boolean;
+}
+declare function StatusChip({ status, label, icon, isLoading, size, showDot }: StatusChipProps): react_jsx_runtime.JSX.Element;
+
+interface QualityBadgeProps {
+    quality: number | null | undefined;
+    className?: string;
+}
+declare function QualityBadge({ quality, className }: QualityBadgeProps): react_jsx_runtime.JSX.Element | null;
+
+interface ProgressBarProps {
+    current: number;
+    total: number;
+    label?: string;
+    className?: string;
+}
+declare function ProgressBar({ current, total, label, className, }: ProgressBarProps): react_jsx_runtime.JSX.Element;
+
+interface ModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    children: React.ReactNode;
+    allowClose?: boolean;
+}
+declare function Modal({ isOpen, onClose, title, children, allowClose, }: ModalProps): React.ReactNode;
+
+interface LoaderProps {
+    size?: number;
+    text?: string;
+    className?: string;
+}
+declare function Loader({ size, text, className }: LoaderProps): react_jsx_runtime.JSX.Element;
+
+declare function Tabs({ defaultValue, value, // Agregado para soportar modo controlado si se necesita
+className, children, onValueChange, }: {
+    defaultValue?: string;
+    value?: string;
+    className?: string;
+    children: React$1.ReactNode;
+    onValueChange?: (value: string) => void;
+}): react_jsx_runtime.JSX.Element;
+declare function TabsList({ className, children, }: {
+    className?: string;
+    children: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function TabsTrigger({ value, children, className, disabled, }: {
+    value: string;
+    children: React$1.ReactNode;
+    className?: string;
+    disabled?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function TabsContent({ value, children, className, }: {
+    value: string;
+    children: React$1.ReactNode;
+    className?: string;
+}): react_jsx_runtime.JSX.Element | null;
+
+type SlotStatus = "pending" | "captured" | "error";
+interface BiometricSlotProps {
+    title: string;
+    position: string;
+    status: SlotStatus;
+    quality?: number | null;
+    imageUrl?: string | null;
+    onCapture: () => void;
+    onRequestMissing?: () => void;
+    onRestore?: () => void;
+    onDelete?: () => void;
+    missingReason?: string | null;
+    iconType: "finger" | "face" | "palm" | "iris";
+    isDisabled?: boolean;
+    className?: string;
+    isLoadedFromBackend?: boolean;
+}
+declare function BiometricSlot({ title, position, status, quality, imageUrl, onCapture, onRequestMissing, onRestore, onDelete, missingReason: externalMissingReason, iconType, isDisabled, className, isLoadedFromBackend, }: BiometricSlotProps): react_jsx_runtime.JSX.Element;
+
+type BiometricType = "finger" | "palm" | "iris" | "face";
+interface MissingBiometricModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: (reason: string) => void;
+    positionName: string;
+    biometricType?: BiometricType;
+}
+declare const MissingBiometricModal: React__default.FC<MissingBiometricModalProps>;
+declare const MissingFingerModal: React__default.FC<MissingBiometricModalProps>;
+
+interface TableWrapperProps {
+    children: React__default.ReactNode;
+    className?: string;
+    variant?: 'default' | 'strong';
+}
+declare const TableWrapper: React__default.FC<TableWrapperProps>;
+interface TableHeaderProps {
+    children: React__default.ReactNode;
+    className?: string;
+}
+declare const TableHeader: React__default.FC<TableHeaderProps>;
+interface TableRowProps {
+    children: React__default.ReactNode;
+    onClick?: () => void;
+    className?: string;
+}
+declare const TableRow: React__default.FC<TableRowProps>;
+
+type MessageHandler = (message: any) => void;
+interface SocketMessage {
+    messageType: string;
+    [key: string]: any;
+}
+interface DeviceStatus {
+    fingerprintDevices: Array<{
+        deviceModel: string;
+        status: string;
+    }>;
+    irisDeviceOpen: boolean;
+}
+interface BiometricState {
+    socket: WebSocket | null;
+    isConnected: boolean;
+    deviceStatus: DeviceStatus | null;
+    lastMessage: SocketMessage | null;
+    handlers: Map<string, MessageHandler>;
+    missingFingers: Record<string, string>;
+    markFingerAsMissing: (position: string, reason: string) => void;
+    restoreFinger: (position: string) => void;
+    clearAllMissingFingers: () => void;
+    getExpectedFingers: (allPositions: string[]) => string[];
+    init: (wsUrl?: string, deviceId?: string) => void;
+    connect: () => void;
+    disconnect: () => void;
+    sendMessage: (message: object) => void;
+    registerHandler: (messageType: string, handler: MessageHandler) => void;
+    unregisterHandler: (messageType: string) => void;
+    resetSession: () => void;
+}
+declare const useBiometricStore: zustand.UseBoundStore<zustand.StoreApi<BiometricState>>;
+
+declare enum FingerprintPosition {
+    RightThumb = "RightThumb",
+    RightIndex = "RightIndex",
+    RightMiddle = "RightMiddle",
+    RightRing = "RightRing",
+    RightLittle = "RightLittle",
+    LeftThumb = "LeftThumb",
+    LeftIndex = "LeftIndex",
+    LeftMiddle = "LeftMiddle",
+    LeftRing = "LeftRing",
+    LeftLittle = "LeftLittle",
+    RightUpperPalm = "RightUpperPalm",
+    RightLowerPalm = "RightLowerPalm",
+    RightWritersPalm = "RightWritersPalm",
+    LeftUpperPalm = "LeftUpperPalm",
+    LeftLowerPalm = "LeftLowerPalm",
+    LeftWritersPalm = "LeftWritersPalm"
+}
+declare enum FingerprintImpressionType {
+    LiveScanPlain = "LiveScanPlain",
+    LiveScanRolled = "LiveScanRolled",
+    RolledContact = "RolledContact",
+    NonLiveScanPlain = "NonLiveScanPlain",
+    NonLiveScanRolled = "NonLiveScanRolled",
+    LatentImpression = "LatentImpression",
+    LatentTracing = "LatentTracing",
+    LatentPhoto = "LatentPhoto",
+    LatentLift = "LatentLift",
+    LiveScanPalm = "LiveScanPalm",
+    NonLiveScanPalm = "NonLiveScanPalm",
+    LatentPalmImpression = "LatentPalmImpression",
+    LatentPalmTracing = "LatentPalmTracing",
+    LatentPalmPhoto = "LatentPalmPhoto",
+    LatentPalmLift = "LatentPalmLift",
+    LiveScanOpticalContactPlain = "LiveScanOpticalContactPlain",
+    LiveScanOpticalContactRolled = "LiveScanOpticalContactRolled",
+    LiveScanOpticalContactlessPlain = "LiveScanOpticalContactlessPlain",
+    LiveScanOpticalContactlessRolled = "LiveScanOpticalContactlessRolled",
+    LiveScanCapacitivePlain = "LiveScanCapacitivePlain",
+    LiveScanCapacitiveRolled = "LiveScanCapacitiveRolled",
+    LiveScanUltrasonicPlain = "LiveScanUltrasonicPlain",
+    LiveScanUltrasonicRolled = "LiveScanUltrasonicRolled",
+    LiveScanThermalPlain = "LiveScanThermalPlain",
+    LiveScanThermalRolled = "LiveScanThermalRolled",
+    LiveScanVerticalSwipe = "LiveScanVerticalSwipe",
+    LiveScanOpticalPalm = "LiveScanOpticalPalm",
+    NonLiveScanOpticalPalm = "NonLiveScanOpticalPalm",
+    Swipe = "Swipe",
+    LiveScanContactless = "LiveScanContactless"
+}
+declare enum IrisPosition {
+    Right = "Right",
+    Left = "Left"
+}
+interface BiometricImage {
+    dataBytes: string;
+}
+interface FingerprintItem {
+    position: FingerprintPosition;
+    impressionType?: FingerprintImpressionType;
+    image: BiometricImage;
+}
+interface MissingFingerprintItem {
+    position: FingerprintPosition;
+    missingReasonCode?: string;
+    missingReasonText?: string;
+}
+interface FaceItem {
+    image: BiometricImage;
+}
+interface MissingFaceItem {
+    index: number;
+    missingReasonCode?: string;
+    missingReasonText?: string;
+}
+interface IrisItem {
+    position: IrisPosition;
+    image: BiometricImage;
+}
+interface MissingIrisItem {
+    position: IrisPosition;
+    missingReasonCode?: string;
+    missingReasonText?: string;
+}
+interface EnrollAction {
+    enrollActionType: "Masterize" | "Verify";
+}
+interface CustomDetails {
+    fullName: string;
+    citizenship?: string;
+    dateOfBirth?: string;
+    gender?: string;
+    [key: string]: any;
+}
+interface EnrollApplicantRequest {
+    externalId: string;
+    enrolledBy?: string;
+    enrollAction: EnrollAction;
+    customDetails: CustomDetails;
+    fingerprintModality?: {
+        fingerprints: FingerprintItem[];
+        missingFingerprints: MissingFingerprintItem[];
+    };
+    faceModality?: {
+        faces: FaceItem[];
+        missingFaces?: MissingFaceItem[];
+    };
+    irisModality?: {
+        irises: IrisItem[];
+        missingIrises?: MissingIrisItem[];
+    };
+}
+
+interface BiometricItem {
+    image: string;
+    quality: number;
+    impressionType?: string;
+}
+interface OriginalSnapshot {
+    fingerprints: Record<string, BiometricItem>;
+    rolledFingerprints: Record<string, BiometricItem>;
+    missingFingers: Record<string, string>;
+    palms: Record<string, BiometricItem>;
+    missingPalms: Record<string, string>;
+    faces: BiometricItem[];
+    faceCaptures: (BiometricItem | null)[];
+    missingFaces: Record<number, string>;
+    irises: {
+        right?: BiometricItem;
+        left?: BiometricItem;
+    };
+    missingIrises: Record<string, string>;
+}
+interface EnrollmentState {
+    externalId: string;
+    fullName: string;
+    isUpdateMode: boolean;
+    isLoading: boolean;
+    fingerprints: Record<string, BiometricItem>;
+    rolledFingerprints: Record<string, BiometricItem>;
+    missingFingers: Record<string, string>;
+    palms: Record<string, BiometricItem>;
+    missingPalms: Record<string, string>;
+    faces: BiometricItem[];
+    faceCaptures: (BiometricItem | null)[];
+    missingFaces: Record<number, string>;
+    irises: {
+        right?: BiometricItem;
+        left?: BiometricItem;
+    };
+    missingIrises: Record<string, string>;
+    _originalSnapshot: OriginalSnapshot | null;
+    setDemographics: (id: string, name: string) => void;
+    addFingerprint: (pos: string, image: string, quality?: number) => void;
+    addRolledFingerprint: (pos: string, image: string, quality?: number) => void;
+    removeFingerprint: (pos: string) => void;
+    removeRolledFingerprint: (pos: string) => void;
+    addMissingFinger: (pos: string, reason: string) => void;
+    removeMissingFinger: (pos: string) => void;
+    addPalm: (pos: string, image: string, quality?: number) => void;
+    removePalm: (pos: string) => void;
+    addMissingPalm: (pos: string, reason: string) => void;
+    removeMissingPalm: (pos: string) => void;
+    setFaces: (items: {
+        image: string;
+        quality: number;
+    }[]) => void;
+    setFaceCaptures: (items: ({
+        image: string;
+        quality: number;
+    } | null)[]) => void;
+    removeFace: (index: number) => void;
+    addMissingFace: (index: number, reason: string) => void;
+    removeMissingFace: (index: number) => void;
+    setIrises: (right?: {
+        image: string;
+        quality: number;
+    }, left?: {
+        image: string;
+        quality: number;
+    }) => void;
+    removeIris: (side: "left" | "right") => void;
+    addMissingIris: (side: string, reason: string) => void;
+    removeMissingIris: (side: string) => void;
+    loadApplicantData: (data: any) => Promise<void>;
+    buildEnrollmentRequest: () => EnrollApplicantRequest;
+    buildUpdateRequest: () => Partial<EnrollApplicantRequest>;
+    getDirtyModalities: () => Set<string>;
+    resetEnrollment: () => void;
+}
+declare const useEnrollmentStore: zustand.UseBoundStore<zustand.StoreApi<EnrollmentState>>;
+
+interface UiState {
+    messages: string[];
+    isConsoleOpen: boolean;
+    addMessage: (message: string) => void;
+    toggleConsole: () => void;
+    clearMessages: () => void;
+}
+declare const useUiStore: zustand.UseBoundStore<zustand.StoreApi<UiState>>;
+
+declare function normalizeImageForStorage(imageString: string | undefined | null): string;
+declare function getImageSrcForDisplay(imageString: string | undefined | null, format?: "png" | "jpeg" | "jpg" | "bmp" | "jp2"): string | undefined;
+declare function isRemoteImage(imageString: string | undefined | null): boolean;
+/**
+ * Descarga una imagen remota y la convierte a base64.
+ * Sigue el patrón de `Utils.downloadResource` de los ABIS training samples.
+ * Para usar en el navegador con fetch + FileReader.
+ */
+declare function downloadImageAsBase64(url: string): Promise<string>;
+declare function canvasToBase64(canvas: HTMLCanvasElement, format?: "image/jpeg" | "image/png", quality?: number): string;
+declare function base64toBlob(base64Data: string): Blob | null;
+declare function detectImageFormat(base64Data: string | undefined | null): string;
+declare function isValidBase64(str: string): boolean;
+
+declare const FINGER_NAMES: Record<string, string>;
+declare const RIGHT_FINGERS: string[];
+declare const LEFT_FINGERS: string[];
+
+declare function setApiBaseUrl(url: string): void;
+declare const api: axios.AxiosInstance;
+
+declare const AuthService: {
+    login: (credentials: {
+        username: string;
+        password: string;
+    }) => Promise<any>;
+};
+declare const BiometricService: {
+    enrollApplicant: (payload: EnrollApplicantRequest) => Promise<any>;
+    updateApplicant: (externalId: string, payload: Partial<EnrollApplicantRequest>) => Promise<any>;
+    getApplicant: (externalId: string) => Promise<any>;
+    verifyIdentity: (externalId: string, biometricData: any) => Promise<any>;
+    identifyProbe: (biometricData: any) => Promise<any>;
+};
+
+interface User {
+    id: string;
+    username: string;
+    role: string;
+}
+interface AuthState {
+    token: string | null;
+    user: User | null;
+    login: (token: string, user: User) => void;
+    logout: () => void;
+    initializeAuth: () => void;
+}
+declare const useAuthStore: zustand.UseBoundStore<zustand.StoreApi<AuthState>>;
+
+export { AuthService, type BiometricConfig, type BiometricImage, type BiometricItem, BiometricProvider, BiometricService, BiometricSlot, type BiometricSlotProps, type BiometricState, Button, type ButtonProps, Card, type CardProps, type CustomDetails, type DeviceStatus, type EnrollAction, type EnrollApplicantRequest, type EnrollmentState, FINGER_NAMES, FaceCameraModal, FaceEnrollModule, type FaceItem, FingerCaptureModal, FingerEnrollModule, FingerRollCaptureModal, FingerRollEnrollModule, FingerprintImpressionType, type FingerprintItem, FingerprintPosition, Input, type InputProps, IrisCameraModal, IrisEnrollModule, type IrisItem, IrisPosition, LEFT_FINGERS, Loader, type MessageHandler, MissingBiometricModal, type MissingFaceItem, MissingFingerModal, type MissingFingerprintItem, type MissingIrisItem, Modal, type ModalProps, ModuleHeader, type OriginalSnapshot, PalmCaptureModal, PalmEnrollModule, ProgressBar, QualityBadge, RIGHT_FINGERS, Select, type SocketMessage, StatusChip, TableHeader, TableRow, TableWrapper, Tabs, TabsContent, TabsList, TabsTrigger, type UiState, api, base64toBlob, canvasToBase64, detectImageFormat, downloadImageAsBase64, getImageSrcForDisplay, isRemoteImage, isValidBase64, normalizeImageForStorage, setApiBaseUrl, useAuthStore, useBiometricConfig, useBiometricStore, useEnrollmentStore, useUiStore };