@moveris/shared 0.0.1 → 1.0.1

package/dist/index.d.ts

@@ -1,130 +1,263 @@
-type MessageType = 'auth_required' | 'auth' | 'auth_success' | 'auth_error' | 'frame' | 'frame_received' | 'processing_complete' | 'error' | 'session_resume';
-interface BaseMessage {
-    type: MessageType;
-    timestamp?: number;
-}
-interface AuthRequiredMessage extends BaseMessage {
-    type: 'auth_required';
-}
-interface AuthMessage extends BaseMessage {
-    type: 'auth';
-    token: string;
-    model_file_name: string;
-}
-interface AuthSuccessMessage extends BaseMessage {
-    type: 'auth_success';
-    request_id: string;
-    last_acked_frame?: number;
-}
-interface AuthErrorMessage extends BaseMessage {
-    type: 'auth_error';
-    error: string;
-    code?: string;
+type Verdict = 'live' | 'fake';
+type FastCheckModel = '10' | '50' | '250';
+type FrameSource = 'media' | 'live';
+type JobStatus = 'queued' | 'processing' | 'complete' | 'failed';
+interface FrameData {
+    index: number;
+    timestamp_ms: number;
+    pixels: string;
+}
+interface CropData {
+    index: number;
+    pixels: string;
+}
+interface HybridFrameData {
+    timestamp_ms: number;
+    pixels: string;
+}
+interface FastCheckRequest {
+    session_id: string;
+    model?: FastCheckModel;
+    source?: FrameSource;
+    frames: FrameData[];
+}
+interface FastCheckCropsRequest {
+    session_id: string;
+    model?: FastCheckModel;
+    source?: FrameSource;
+    crops: CropData[];
+}
+interface VerifyRequest {
+    session_id: string;
+    capture_start_ms?: number;
+    frame_width?: number;
+    frame_height?: number;
+    fps?: number;
+    frames: FrameData[];
+}
+interface HybridCheckRequest {
+    session_id: string;
+    fps?: number;
+    frames: HybridFrameData[];
 }
-interface FrameMessage extends BaseMessage {
-    type: 'frame';
-    frame_data: string;
-    frame_number: number;
+interface Hybrid50CheckRequest {
+    session_id: string;
+    fps?: number;
+    frames: HybridFrameData[];
 }
-interface FrameReceivedMessage extends BaseMessage {
-    type: 'frame_received';
-    frame_number: number;
+interface Hybrid150CheckRequest {
+    session_id: string;
+    fps?: number;
+    frames: HybridFrameData[];
 }
-interface ProcessingCompleteMessage extends BaseMessage {
-    type: 'processing_complete';
-    request_id: string;
-    prediction: 'real' | 'spoof';
+interface FastCheckResponse {
+    verdict: Verdict | null;
+    confidence: number | null;
+    real_score: number | null;
+    score: number | null;
+    session_id: string;
+    model: string | null;
+    processing_ms: number;
+    frames_processed: number;
+    available: boolean;
+    warning: string | null;
+    error: string | null;
+}
+interface VerifyResponse {
+    verdict: Verdict;
     confidence: number;
+    real_score: number;
+    score: number;
+    session_id: string;
+    processing_ms: number;
+}
+interface HybridCheckResponse {
+    verdict: Verdict | null;
+    confidence: number | null;
+    real_score: number | null;
+    score: number | null;
+    visual_score: number | null;
+    physio_extracted: boolean;
+    session_id: string;
+    processing_ms: number;
+    frames_processed: number;
+    available: boolean;
+    warning: string | null;
+    error: string | null;
+}
+interface JobStatusResponse {
+    job_id: string;
+    status: JobStatus;
+    session_id: string | null;
+    created_at: string | null;
+    started_at: string | null;
+    completed_at: string | null;
+    verdict: Verdict | null;
+    confidence: number | null;
+    real_score: number | null;
+    processing_ms: number | null;
+    frames_processed: number | null;
+    available: boolean;
+    warning: string | null;
+    error: string | null;
+}
+interface QueueStatsResponse {
+    queue_length: number;
+    queue_key: string;
 }
-interface ErrorMessage extends BaseMessage {
-    type: 'error';
+interface HealthResponse {
+    status: string;
+    version: string;
+    environment: string;
+    models_loaded?: string[];
+    dependencies?: Record<string, unknown>;
+}
+interface ErrorResponse {
     error: string;
-    code: string;
+    message: string;
+    required?: number;
+    received?: number;
+}
+interface LivenessResult {
+    verdict: Verdict;
+    confidence: number;
+    score: number;
+    sessionId: string;
+    processingMs: number;
+    framesProcessed: number;
+}
+type LivenessState = 'idle' | 'capturing' | 'uploading' | 'processing' | 'complete' | 'error';
+interface LivenessConfig {
+    baseUrl: string;
+    apiKey: string;
+    model?: FastCheckModel;
+    source?: FrameSource;
+    fps?: number;
+    frameCount?: number;
+    timeout?: number;
+}
+interface CapturedFrame {
+    index: number;
+    timestampMs: number;
+    pixels: string;
+}
+
+type ModelType = FastCheckModel;
+interface ModelConfig {
+    type: FastCheckModel;
+    minFrames: number;
+    recommendedFrames: number;
+    description: string;
 }
-interface SessionResumeMessage extends BaseMessage {
-    type: 'session_resume';
-    last_acked_frame: number;
+declare const MODEL_CONFIGS: Record<FastCheckModel, ModelConfig>;
+interface HybridModelConfig {
+    type: 'hybrid-50' | 'hybrid-150';
+    minFrames: number;
+    recommendedFps: number;
+    captureDurationSeconds: number;
+    description: string;
 }
-type WebSocketMessage = AuthRequiredMessage | AuthMessage | AuthSuccessMessage | AuthErrorMessage | FrameMessage | FrameReceivedMessage | ProcessingCompleteMessage | ErrorMessage | SessionResumeMessage;
+declare const HYBRID_MODEL_CONFIGS: Record<string, HybridModelConfig>;
+declare function getMinFramesForModel(model: FastCheckModel): number;
+declare function hasEnoughFrames(model: FastCheckModel, frameCount: number): boolean;
 
 interface Frame {
-    number: number;
+    index: number;
     data: string;
     timestamp: number;
     size: number;
 }
-type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
-interface LivenessResult {
-    prediction: 'real' | 'spoof';
-    confidence: number;
-    requestId: string;
-}
 type OnResultCallback = (result: LivenessResult) => void;
 type OnErrorCallback = (error: Error) => void;
-type OnFrameAckCallback = (frameNumber: number) => void;
-type OnConnectionStateChangeCallback = (state: ConnectionState) => void;
+type OnFrameCapturedCallback = (frame: Frame) => void;
 type OnProgressCallback = (current: number, total: number) => void;
+type OnStateChangeCallback = (state: LivenessState) => void;
 interface LivenessCallbacks {
     onResult?: OnResultCallback;
     onError?: OnErrorCallback;
-    onFrameAck?: OnFrameAckCallback;
-    onConnectionStateChange?: OnConnectionStateChangeCallback;
+    onFrameCaptured?: OnFrameCapturedCallback;
     onProgress?: OnProgressCallback;
+    onStateChange?: OnStateChangeCallback;
 }
 
-interface WebSocketClientConfig {
-    url: string;
+interface LivenessClientConfig {
+    baseUrl?: string;
     apiKey: string;
-    model: string;
-    onMessage?: (message: WebSocketMessage) => void;
-    onConnectionStateChange?: OnConnectionStateChangeCallback;
-    onError?: (error: Error) => void;
-}
-declare class WebSocketClient {
-    private ws;
-    private connectionManager;
-    private authManager;
-    private config;
-    private state;
-    constructor(config: WebSocketClientConfig);
-    connect(): Promise<void>;
-    disconnect(): void;
-    sendFrame(frameData: string, frameNumber: number): void;
-    getState(): ConnectionState;
-    private setState;
-    private handleMessage;
-    private handleError;
+    timeout?: number;
+    enableRetry?: boolean;
+    customFetch?: typeof fetch;
 }
-
-declare class AuthManager {
-    authenticate(ws: WebSocket, apiKey: string, model: string): Promise<string>;
-}
-
-interface ConnectionManagerConfig {
-    onReconnect: () => Promise<void>;
-    maxAttempts?: number;
+declare class LivenessApiError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    readonly required?: number;
+    readonly received?: number;
+    constructor(message: string, code: string, statusCode: number, required?: number, received?: number);
 }
-declare class ConnectionManager {
-    private config;
-    private reconnectAttempts;
-    constructor(config: ConnectionManagerConfig);
-    handleDisconnect(): Promise<void>;
-    reset(): void;
+declare function toFrameData(frames: CapturedFrame[]): FrameData[];
+declare function toHybridFrameData(frames: CapturedFrame[]): HybridFrameData[];
+declare function toLivenessResult(response: FastCheckResponse | VerifyResponse | HybridCheckResponse): LivenessResult;
+declare function generateSessionId(): string;
+declare class LivenessClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly timeout;
+    private readonly enableRetry;
+    private readonly fetchFn;
+    constructor(config: LivenessClientConfig);
+    private request;
+    private requestWithRetry;
+    health(): Promise<HealthResponse>;
+    queueStats(): Promise<QueueStatsResponse>;
+    fastCheck(frames: CapturedFrame[], options?: {
+        sessionId?: string;
+        model?: FastCheckModel;
+        source?: FrameSource;
+    }): Promise<LivenessResult>;
+    fastCheckCrops(crops: CropData[], options?: {
+        sessionId?: string;
+        model?: FastCheckModel;
+        source?: FrameSource;
+    }): Promise<LivenessResult>;
+    verify(frames: CapturedFrame[], options?: {
+        sessionId?: string;
+        captureStartMs?: number;
+        frameWidth?: number;
+        frameHeight?: number;
+        fps?: number;
+    }): Promise<LivenessResult>;
+    hybridCheck(frames: CapturedFrame[], options?: {
+        sessionId?: string;
+        fps?: number;
+    }): Promise<LivenessResult>;
+    hybrid50(frames: CapturedFrame[], options?: {
+        sessionId?: string;
+        fps?: number;
+    }): Promise<LivenessResult>;
+    hybrid150(frames: CapturedFrame[], options?: {
+        sessionId?: string;
+        fps?: number;
+    }): Promise<LivenessResult>;
+    getJobResult(jobId: string): Promise<JobStatusResponse>;
+    waitForJobResult(jobId: string, timeout?: number): Promise<JobStatusResponse>;
 }
 
 declare class FrameBuffer {
     private buffer;
-    private lastAcknowledged;
     private currentMemoryUsage;
     private readonly maxSize;
     private readonly maxMemory;
     constructor(maxSize?: number, maxMemory?: number);
     add(frame: Frame): void;
-    acknowledge(frameNumber: number): void;
-    getUnacknowledged(): Frame[];
-    getLastAcknowledged(): number;
+    get(index: number): Frame | undefined;
+    getAll(): Frame[];
+    getRange(startIndex: number, endIndex: number): Frame[];
+    getLatest(count: number): Frame[];
+    removeUpTo(index: number): void;
     size(): number;
     getMemoryUsage(): number;
+    isEmpty(): boolean;
+    isFull(): boolean;
     clear(): void;
     private remove;
     private flushOldest;
@@ -141,24 +274,27 @@ declare class FrameQueue {
     toArray(): Frame[];
 }
 
-type ModelType = '50-frame' | '250-frame';
-interface ModelConfig {
-    type: ModelType;
-    fileName: string;
-    frameCount: number;
-}
-declare const MODEL_CONFIGS: Record<ModelType, ModelConfig>;
-
 declare const API_ENDPOINTS: {
-    readonly production: "wss://api.moveris.com/v1/liveness";
-    readonly staging: "wss://staging-api.moveris.com/v1/liveness";
-    readonly development: "ws://localhost:8080/v1/liveness";
+    readonly production: "https://api.moveris.com";
+    readonly staging: "https://moveris-api-v2-staging.fly.dev";
+    readonly development: "http://localhost:8000";
+};
+declare const DEFAULT_ENDPOINT: "https://api.moveris.com";
+declare const API_PATHS: {
+    readonly health: "/health";
+    readonly fastCheck: "/api/v1/fast-check";
+    readonly fastCheckCrops: "/api/v1/fast-check-crops";
+    readonly verify: "/api/v1/verify";
+    readonly hybridCheck: "/api/v1/hybrid-check";
+    readonly hybrid50: "/api/v1/hybrid-50";
+    readonly hybrid150: "/api/v1/hybrid-150";
+    readonly jobResult: "/api/v1/result";
+    readonly queueStats: "/api/v1/queue/stats";
 };
-declare const DEFAULT_ENDPOINT: "wss://api.moveris.com/v1/liveness";
-declare const RECONNECTION_CONFIG: {
-    readonly maxAttempts: 10;
+declare const RETRY_CONFIG: {
+    readonly maxAttempts: 3;
     readonly initialDelay: 1000;
-    readonly maxDelay: 30000;
+    readonly maxDelay: 10000;
     readonly backoffMultiplier: 2;
 };
 declare const FRAME_BUFFER_CONFIG: {
@@ -166,18 +302,127 @@ declare const FRAME_BUFFER_CONFIG: {
     readonly maxMemory: number;
 };
 declare const AUTH_CONFIG: {
-    readonly timeout: 10000;
-    readonly apiKeyPattern: RegExp;
+    readonly timeout: 30000;
+    readonly apiKeyHeader: "X-API-Key";
 };
 declare const FRAME_CONFIG: {
     readonly targetFPS: 30;
     readonly frameInterval: 33;
     readonly jpegQuality: 0.8;
+    readonly defaultModel: "10";
+    readonly defaultSource: "live";
+};
+declare const DEFAULT_LIVENESS_CONFIG: {
+    readonly model: "10";
+    readonly source: "live";
+    readonly fps: 30;
+    readonly timeout: 30000;
 };
 
+declare const ALIGNMENT_THRESHOLD_CAPTURE = 0.6;
+declare const ALIGNMENT_THRESHOLD_POOR = 0.5;
+declare const ALIGNMENT_THRESHOLD_GOOD = 0.5;
+declare const ALIGNMENT_THRESHOLD_PERFECT = 0.85;
+type OvalGuideState = 'no_face' | 'poor' | 'good' | 'perfect';
+declare const OVAL_GUIDE_COLORS: {
+    readonly no_face: "#ef4444";
+    readonly poor: "#f97316";
+    readonly good: "#eab308";
+    readonly perfect: "#22c55e";
+};
+declare const OVAL_GUIDE_STYLES: {
+    readonly no_face: {
+        readonly color: "#ef4444";
+        readonly dashed: true;
+        readonly pulse: false;
+    };
+    readonly poor: {
+        readonly color: "#f97316";
+        readonly dashed: false;
+        readonly pulse: false;
+    };
+    readonly good: {
+        readonly color: "#eab308";
+        readonly dashed: false;
+        readonly pulse: false;
+    };
+    readonly perfect: {
+        readonly color: "#22c55e";
+        readonly dashed: false;
+        readonly pulse: true;
+    };
+};
+declare function getOvalGuideState(hasFace: boolean, alignment: number): OvalGuideState;
+declare const DEFAULT_STATUS_MESSAGES: {
+    readonly idle: "Ready to start";
+    readonly capturing: "Hold still...";
+    readonly uploading: "Processing...";
+    readonly processing: "Analyzing...";
+    readonly complete: "Complete!";
+    readonly error: "Error occurred";
+};
+type StatusMessageKey = keyof typeof DEFAULT_STATUS_MESSAGES;
+declare const FEEDBACK_MESSAGES: {
+    readonly position_face: "Position your face in the oval";
+    readonly no_face: "No face detected - move into frame";
+    readonly multiple_faces: "Multiple people detected - please verify alone";
+    readonly move_closer_to_center: "Move closer to center";
+    readonly center_face: "Center your face";
+    readonly almost_there: "Almost there...";
+    readonly keep_steady: "Keep steady...";
+    readonly perfect: "Perfect! Hold still";
+    readonly scanning: "Scanning...";
+    readonly move_closer: "Move closer - face too far";
+    readonly move_back: "Move back - face too close";
+    readonly too_close: "Move back - face too close";
+    readonly too_far: "Move closer - face too far";
+    readonly face_not_visible: "Center your face - edges cut off";
+    readonly partial_face: "Center your face - edges cut off";
+    readonly hold_still: "Hold still - image blurry";
+    readonly blurry: "Hold still - image blurry";
+    readonly poor_lighting: "Improve lighting";
+    readonly too_dark: "Low lighting - move to a brighter area";
+    readonly backlit: "Backlit - try facing the light source";
+    readonly hand_detected: "Remove hand from face";
+    readonly capturing: "Capturing...";
+    readonly almost_done: "Almost done...";
+    readonly verification_complete: "Verification complete";
+    readonly align_face: "Align your face";
+};
+type FeedbackMessageKey = keyof typeof FEEDBACK_MESSAGES;
+interface FeedbackLocale {
+    status: Record<StatusMessageKey, string>;
+    feedback: Record<FeedbackMessageKey, string>;
+}
+declare const DEFAULT_LOCALE: FeedbackLocale;
+declare const ES_LOCALE: FeedbackLocale;
+declare function getFeedbackMessage(key: FeedbackMessageKey, locale?: FeedbackLocale): string;
+declare function getStatusMessage(key: StatusMessageKey, locale?: FeedbackLocale): string;
+interface CaptureQualityState {
+    hasFace: boolean;
+    alignment: number;
+    isCapturing: boolean;
+    tooClose: boolean;
+    tooFar: boolean;
+    isBlurry: boolean;
+    isPartialFace: boolean;
+    framesCaptured: number;
+    targetFrames: number;
+}
+declare function getCaptureQualityFeedback(state: CaptureQualityState): string;
+declare function canCaptureFrame(state: Omit<CaptureQualityState, 'framesCaptured' | 'targetFrames' | 'isCapturing'>): boolean;
+
 declare function validateApiKey(apiKey: string): boolean;
 declare function validateFrameData(data: string): boolean;
-declare function validateFrameNumber(frameNumber: number): boolean;
+declare function validateFrameIndex(index: number): boolean;
+declare function validateTimestamp(timestamp: number): boolean;
+declare function validateFrameCount(model: FastCheckModel, frameCount: number): {
+    valid: boolean;
+    required: number;
+    received: number;
+};
+declare function validateUUID(uuid: string): boolean;
+declare function validateUrl(url: string): boolean;
 
 declare function encodeBase64(buffer: ArrayBuffer | Uint8Array): string;
 declare function decodeBase64(base64: string): Uint8Array;
@@ -187,7 +432,113 @@ interface RetryOptions {
     initialDelay?: number;
     maxDelay?: number;
     backoffMultiplier?: number;
+    isRetryable?: (error: unknown) => boolean;
 }
 declare function retryWithBackoff<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+declare function sleep(ms: number): Promise<void>;
+
+interface FaceBoundingBox {
+    originX: number;
+    originY: number;
+    width: number;
+    height: number;
+}
+interface BlurAnalysis {
+    variance: number;
+    isBlurry: boolean;
+    threshold: number;
+}
+interface LightingAnalysis {
+    faceBrightness: number;
+    backgroundBrightness: number;
+    ratio: number;
+    status: 'good' | 'backlit' | 'low_light';
+    warning?: string;
+}
+interface FaceVisibilityResult {
+    visible: boolean;
+    reason?: string;
+}
+interface FaceAlignmentResult {
+    score: number;
+    tooClose: boolean;
+    tooFar: boolean;
+}
+interface OvalRegion {
+    centerX: number;
+    centerY: number;
+    width: number;
+    height: number;
+}
+interface FaceInOvalResult {
+    isInside: boolean;
+    centerInOval: boolean;
+    sizeMatch: boolean;
+    feedback?: string;
+}
+interface FrameQualityResult {
+    passed: boolean;
+    blur?: BlurAnalysis;
+    lighting?: LightingAnalysis;
+    visibility?: FaceVisibilityResult;
+    alignment?: FaceAlignmentResult;
+    rejectionReason?: 'blur' | 'backlit' | 'low_light' | 'partial_face' | 'no_face' | 'too_close' | 'too_far' | 'misaligned';
+}
+declare const DEFAULT_BLUR_THRESHOLD = 100;
+declare const BLUR_THRESHOLD_MOBILE = 150;
+declare const BACKLIT_RATIO_THRESHOLD = 0.6;
+declare const LOW_LIGHT_THRESHOLD = 50;
+declare const MIN_FACE_TOP_MARGIN = 0.1;
+declare const MIN_FACE_BOTTOM_MARGIN = 0.08;
+declare const MIN_FACE_SIDE_MARGIN = 0.05;
+declare const MIN_CAPTURE_ALIGNMENT = 0.6;
+declare const HIGH_ALIGNMENT = 0.85;
+declare const GOOD_ALIGNMENT = 0.5;
+declare const IDEAL_CROP_MULTIPLIER = 3.33;
+declare const MIN_CROP_MULTIPLIER = 1.5;
+declare const MAX_CROP_MULTIPLIER = 4;
+declare const FACE_CENTER_VERTICAL_OFFSET = 0.15;
+declare const MIN_FACE_RATIO = 0.03;
+declare const MAX_FACE_RATIO = 0.7;
+declare const FACE_CROP_OUTPUT_SIZE = 224;
+declare const MAX_FACE_PERCENTAGE_IN_CROP = 0.5;
+declare const TARGET_FACE_PERCENTAGE_IN_CROP = 0.3;
+declare function analyzeBlur(grayscalePixels: number[], width: number, height: number, threshold?: number): BlurAnalysis;
+declare function rgbaToGrayscale(rgbaPixels: Uint8ClampedArray | number[]): number[];
+declare function calculateBrightness(rgbaPixels: Uint8ClampedArray | number[]): number;
+declare function analyzeLighting(faceBrightness: number, backgroundBrightness: number): LightingAnalysis;
+declare function isFaceFullyVisible(boundingBox: FaceBoundingBox, frameWidth: number, frameHeight: number): FaceVisibilityResult;
+declare const DEFAULT_OVAL_REGION: OvalRegion;
+declare function isFaceInOval(faceBox: FaceBoundingBox, frameWidth: number, frameHeight: number, oval?: OvalRegion, tolerance?: number): FaceInOvalResult;
+declare function calculateFaceAlignment(boundingBox: FaceBoundingBox, frameWidth: number, frameHeight: number): FaceAlignmentResult;
+declare function calculateAdaptiveCropMultiplier(faceBox: FaceBoundingBox, frameWidth: number, frameHeight: number): number;
+declare function isFaceCropFullyInFrame(faceBox: FaceBoundingBox, frameWidth: number, frameHeight: number): boolean;
+declare function calculateFaceCropRegion(faceBox: FaceBoundingBox, frameWidth: number, frameHeight: number): {
+    x: number;
+    y: number;
+    size: number;
+};
+declare function checkFrameQuality(options: {
+    faceBox?: FaceBoundingBox;
+    frameWidth: number;
+    frameHeight: number;
+    blurAnalysis?: BlurAnalysis;
+    lightingAnalysis?: LightingAnalysis;
+    minAlignment?: number;
+}): FrameQualityResult;
+declare class BaseFrameCollector {
+    protected frames: CapturedFrame[];
+    protected maxFrames: number;
+    protected startTime: number;
+    constructor(maxFrames?: number);
+    setMaxFrames(max: number): void;
+    addFrame(frame: CapturedFrame): void;
+    getFrames(): CapturedFrame[];
+    getCount(): number;
+    isComplete(): boolean;
+    reset(): void;
+    getStartTime(): number;
+    getNextIndex(): number;
+}
 
-export { API_ENDPOINTS, AUTH_CONFIG, type AuthErrorMessage, AuthManager, type AuthMessage, type AuthRequiredMessage, type AuthSuccessMessage, type BaseMessage, ConnectionManager, type ConnectionState, DEFAULT_ENDPOINT, type ErrorMessage, FRAME_BUFFER_CONFIG, FRAME_CONFIG, type Frame, FrameBuffer, type FrameMessage, FrameQueue, type FrameReceivedMessage, type LivenessCallbacks, type LivenessResult, MODEL_CONFIGS, type MessageType, type ModelConfig, type ModelType, type OnConnectionStateChangeCallback, type OnErrorCallback, type OnFrameAckCallback, type OnProgressCallback, type OnResultCallback, type ProcessingCompleteMessage, RECONNECTION_CONFIG, type RetryOptions, type SessionResumeMessage, WebSocketClient, type WebSocketMessage, decodeBase64, encodeBase64, retryWithBackoff, validateApiKey, validateFrameData, validateFrameNumber };
+export { ALIGNMENT_THRESHOLD_CAPTURE, ALIGNMENT_THRESHOLD_GOOD, ALIGNMENT_THRESHOLD_PERFECT, ALIGNMENT_THRESHOLD_POOR, API_ENDPOINTS, API_PATHS, AUTH_CONFIG, BACKLIT_RATIO_THRESHOLD, BLUR_THRESHOLD_MOBILE, BaseFrameCollector, type BlurAnalysis, type CaptureQualityState, type CapturedFrame, type CropData, DEFAULT_BLUR_THRESHOLD, DEFAULT_ENDPOINT, DEFAULT_LIVENESS_CONFIG, DEFAULT_LOCALE, DEFAULT_OVAL_REGION, DEFAULT_STATUS_MESSAGES, ES_LOCALE, type ErrorResponse, FACE_CENTER_VERTICAL_OFFSET, FACE_CROP_OUTPUT_SIZE, FEEDBACK_MESSAGES, FRAME_BUFFER_CONFIG, FRAME_CONFIG, type FaceAlignmentResult, type FaceBoundingBox, type FaceInOvalResult, type FaceVisibilityResult, type FastCheckCropsRequest, type FastCheckModel, type FastCheckRequest, type FastCheckResponse, type FeedbackLocale, type FeedbackMessageKey, type Frame, FrameBuffer, type FrameData, type FrameQualityResult, FrameQueue, type FrameSource, GOOD_ALIGNMENT, HIGH_ALIGNMENT, HYBRID_MODEL_CONFIGS, type HealthResponse, type Hybrid150CheckRequest, type Hybrid50CheckRequest, type HybridCheckRequest, type HybridCheckResponse, type HybridFrameData, type HybridModelConfig, IDEAL_CROP_MULTIPLIER, type JobStatus, type JobStatusResponse, LOW_LIGHT_THRESHOLD, type LightingAnalysis, LivenessApiError, type LivenessCallbacks, LivenessClient, type LivenessClientConfig, type LivenessConfig, type LivenessResult, type LivenessState, MAX_CROP_MULTIPLIER, MAX_FACE_PERCENTAGE_IN_CROP, MAX_FACE_RATIO, MIN_CAPTURE_ALIGNMENT, MIN_CROP_MULTIPLIER, MIN_FACE_BOTTOM_MARGIN, MIN_FACE_RATIO, MIN_FACE_SIDE_MARGIN, MIN_FACE_TOP_MARGIN, MODEL_CONFIGS, type ModelConfig, type ModelType, OVAL_GUIDE_COLORS, OVAL_GUIDE_STYLES, type OnErrorCallback, type OnFrameCapturedCallback, type OnProgressCallback, type OnResultCallback, type OnStateChangeCallback, type OvalGuideState, type OvalRegion, type QueueStatsResponse, RETRY_CONFIG, type RetryOptions, type StatusMessageKey, TARGET_FACE_PERCENTAGE_IN_CROP, type Verdict, type VerifyRequest, type VerifyResponse, analyzeBlur, analyzeLighting, calculateAdaptiveCropMultiplier, calculateBrightness, calculateFaceAlignment, calculateFaceCropRegion, canCaptureFrame, checkFrameQuality, decodeBase64, encodeBase64, generateSessionId, getCaptureQualityFeedback, getFeedbackMessage, getMinFramesForModel, getOvalGuideState, getStatusMessage, hasEnoughFrames, isFaceCropFullyInFrame, isFaceFullyVisible, isFaceInOval, retryWithBackoff, rgbaToGrayscale, sleep, toFrameData, toHybridFrameData, toLivenessResult, validateApiKey, validateFrameCount, validateFrameData, validateFrameIndex, validateTimestamp, validateUUID, validateUrl };