@cabek/sdk/dist/cabek-sdk.d.ts

Official JavaScript/TypeScript SDK for C.A.B.E.K. biometric authentication

/**
 * C.A.B.E.K. JavaScript/TypeScript SDK
 * Official SDK for integrating C.A.B.E.K. biometric authentication
 *
 * @packageDocumentation
 */
import EventEmitter from 'events';
/**
 * Authentication state enum
 */
export declare enum AuthenticationState {
    IDLE = "idle",
    AUTHENTICATING = "authenticating",
    AUTHENTICATED = "authenticated",
    FAILED = "failed",
    LOCKED = "locked"
}
/**
 * Device types supported by C.A.B.E.K.
 */
export declare enum DeviceType {
    SMARTWATCH = "smartwatch",
    CHEST_STRAP = "chest_strap",
    PATCH = "patch",
    WEB = "web"
}
/**
 * Result of an authentication attempt
 */
export interface AuthenticationResult {
    success: boolean;
    confidence: number;
    ephemeralToken?: string;
    expiresMs: number;
    userId?: string;
    deviceId?: string;
    error?: string;
    timestamp?: number;
}
/**
 * Result of biometric enrollment
 */
export interface EnrollmentResult {
    success: boolean;
    userId?: string;
    deviceId?: string;
    message?: string;
    error?: string;
}
/**
 * Information about a connected device
 */
export interface DeviceInfo {
    deviceId: string;
    deviceType: DeviceType;
    model?: string;
    firmwareVersion?: string;
    batteryLevel?: number;
    samplingRate: number;
    isConnected: boolean;
    lastSeen?: Date;
}
/**
 * Signal quality validation result
 */
export interface SignalQualityResult {
    valid: boolean;
    qualityScore: number;
    issues: string[];
    metrics: {
        std: number;
        mean: number;
        snr: number;
        samples: number;
    };
}
/**
 * Session statistics
 */
export interface SessionStats {
    sessionId: string;
    status: string;
    userId: string;
    deviceId: string;
    authFrequencyHz: number;
    startedAt: string;
    authCount: number;
    successCount: number;
    successRate: number;
    lastAuth?: string;
}
/**
 * Configuration options for C.A.B.E.K. SDK
 */
export interface CABEKConfig {
    apiKey: string;
    apiUrl?: string;
    timeout?: number;
    autoReconnect?: boolean;
    debug?: boolean;
}
/**
 * Custom exceptions for C.A.B.E.K. SDK
 */
export declare class CABEKException extends Error {
    constructor(message: string);
}
export declare class AuthenticationException extends CABEKException {
    constructor(message: string);
}
export declare class ConnectionException extends CABEKException {
    constructor(message: string);
}
export declare class SignalQualityException extends CABEKException {
    constructor(message: string);
}
/**
 * Main C.A.B.E.K. SDK Client
 *
 * @example
 * ```typescript
 * const cabek = new CABEK({ apiKey: 'sk_live_...' });
 * const result = await cabek.authenticate(ecgData);
 * ```
 */
export declare class CABEK extends EventEmitter {
    private config;
    private axios;
    private websocket?;
    private state;
    private currentSessionId?;
    private connectedDevices;
    /**
     * Create a new C.A.B.E.K. client
     * @param config - Configuration options
     */
    constructor(config: CABEKConfig);
    /**
     * Handle axios errors
     */
    private handleAxiosError;
    /**
     * Generate a unique device ID
     */
    private generateDeviceId;
    /**
     * Log debug messages
     */
    private debug;
    /**
     * Enroll a user for biometric authentication
     *
     * @param userId - Unique user identifier
     * @param ecgData - ECG signal data for enrollment
     * @param deviceId - Optional device identifier
     * @param deviceType - Type of device used
     * @returns Enrollment result
     */
    enroll(userId: string, ecgData: number[], deviceId?: string, deviceType?: DeviceType): Promise<EnrollmentResult>;
    /**
     * Authenticate using ECG biometric data
     *
     * @param ecgData - ECG signal data
     * @param userId - Optional user identifier
     * @param deviceId - Optional device identifier
     * @returns Authentication result
     */
    authenticate(ecgData: number[], userId?: string, deviceId?: string): Promise<AuthenticationResult>;
    /**
     * Start continuous authentication stream
     *
     * @param ecgStreamCallback - Async generator that yields ECG data
     * @param userId - User identifier
     * @param deviceId - Optional device identifier
     * @param authFrequencyHz - Authentication frequency in Hz
     */
    startContinuousAuth(ecgStreamCallback: AsyncGenerator<number[]>, userId: string, deviceId?: string, authFrequencyHz?: number): Promise<void>;
    /**
     * End continuous authentication session
     */
    endContinuousAuth(): Promise<void>;
    /**
     * Validate ECG signal quality
     *
     * @param ecgData - ECG signal data to validate
     * @returns Signal quality metrics
     */
    validateSignalQuality(ecgData: number[]): Promise<SignalQualityResult>;
    /**
     * Get session statistics
     *
     * @param sessionId - Optional session ID (uses current if not provided)
     * @returns Session statistics
     */
    getSessionStats(sessionId?: string): Promise<SessionStats | null>;
    /**
     * Connect a biometric device
     *
     * @param deviceType - Type of device
     * @param connectionParams - Device-specific connection parameters
     * @returns Device information
     */
    connectDevice(deviceType: DeviceType, connectionParams: Record<string, any>): Promise<DeviceInfo>;
    /**
     * Disconnect a biometric device
     *
     * @param deviceId - Device identifier
     */
    disconnectDevice(deviceId: string): Promise<void>;
    /**
     * Get all connected devices
     */
    getConnectedDevices(): DeviceInfo[];
    /**
     * Get current authentication state
     */
    getState(): AuthenticationState;
    /**
     * Check if client is authenticated
     */
    isAuthenticated(): boolean;
    /**
     * Helper function to sleep
     */
    private sleep;
    /**
     * Cleanup resources
     */
    cleanup(): Promise<void>;
}
/**
 * Quick authentication helper
 *
 * @param apiKey - C.A.B.E.K. API key
 * @param ecgData - ECG signal data
 * @param userId - Optional user identifier
 * @returns Authentication result
 */
export declare function quickAuthenticate(apiKey: string, ecgData: number[], userId?: string): Promise<AuthenticationResult>;
export default CABEK;