@keverdjs/fraud-sdk-react 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,365 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/**
+ * Keverd Fraud SDK React - Type Definitions
+ */
+interface KeverdDeviceInfo {
+    deviceId: string;
+    fingerprint: string;
+    manufacturer?: string;
+    model?: string;
+    brand?: string;
+    device?: string;
+    product?: string;
+    hardware?: string;
+    sdkVersion?: string;
+    osVersion?: string;
+    screenWidth?: string;
+    screenHeight?: string;
+    screenDensity?: string;
+    locale?: string;
+    timezone: string;
+}
+interface KeverdSessionInfo {
+    sessionId?: string;
+    installId?: string;
+    sessionCount?: string;
+    firstSession?: string;
+    timestamp?: string;
+}
+interface KeverdBehavioralData {
+    typing_dwell_ms?: number[];
+    typing_flight_ms?: number[];
+    swipe_velocity?: number;
+    session_entropy?: number;
+}
+interface KeverdFingerprintRequest {
+    userId?: string;
+    device: KeverdDeviceInfo;
+    session?: KeverdSessionInfo;
+    behavioral?: KeverdBehavioralData;
+}
+interface KeverdSimSwapEngine {
+    userId?: string;
+    risk: number;
+    flags: {
+        sim_changed?: boolean;
+        device_changed?: boolean;
+        behavior_anomaly?: boolean;
+        time_anomaly?: boolean;
+        velocity_anomaly?: boolean;
+    };
+    updatedProfile?: Record<string, unknown>;
+}
+interface KeverdFingerprintResponse {
+    risk_score: number;
+    score: number;
+    action: 'allow' | 'soft_challenge' | 'hard_challenge' | 'block';
+    reason: string[];
+    session_id: string;
+    requestId: string;
+    sim_swap_engine?: KeverdSimSwapEngine;
+}
+interface KeverdVisitorData {
+    visitorId: string;
+    riskScore: number;
+    score: number;
+    action: 'allow' | 'soft_challenge' | 'hard_challenge' | 'block';
+    reasons: string[];
+    sessionId: string;
+    requestId: string;
+    simSwapEngine?: KeverdSimSwapEngine;
+    confidence?: number;
+}
+interface KeverdConfig {
+    apiKey: string;
+    endpoint?: string;
+    userId?: string;
+    debug?: boolean;
+    extendedResult?: boolean;
+    ignoreCache?: boolean;
+}
+interface KeverdLoadOptions {
+    apiKey: string;
+    endpoint?: string;
+    debug?: boolean;
+}
+interface KeverdVisitorDataOptions {
+    extendedResult?: boolean;
+    ignoreCache?: boolean;
+    tag?: string;
+}
+interface KeverdVisitorDataHookOptions {
+    extendedResult?: boolean;
+    immediate?: boolean;
+    ignoreCache?: boolean;
+}
+interface KeverdError {
+    message: string;
+    code?: string;
+    statusCode?: number;
+}
+interface KeverdVisitorDataResult$1 {
+    isLoading: boolean;
+    error: KeverdError | null;
+    data: KeverdVisitorData | null;
+    getData: (options?: KeverdVisitorDataOptions) => Promise<KeverdVisitorData>;
+}
+
+/**
+ * Keverd Fraud SDK Core
+ * Main SDK class for fingerprinting and risk assessment
+ */
+
+declare class KeverdSDK {
+    private config;
+    private deviceCollector;
+    private behavioralCollector;
+    private isInitialized;
+    private sessionId;
+    constructor();
+    /**
+     * Initialize the SDK with configuration
+     */
+    init(config: KeverdConfig): void;
+    /**
+     * Get visitor data (fingerprint and risk assessment)
+     */
+    getVisitorData(options?: KeverdVisitorDataOptions): Promise<KeverdVisitorData>;
+    /**
+     * Send fingerprint request to backend
+     */
+    private sendFingerprintRequest;
+    /**
+     * Transform API response to visitor data format
+     */
+    private transformResponse;
+    /**
+     * Get default endpoint
+     */
+    private getDefaultEndpoint;
+    /**
+     * Generate a session ID
+     */
+    private generateSessionId;
+    /**
+     * Destroy the SDK instance
+     */
+    destroy(): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): KeverdConfig | null;
+    /**
+     * Check if SDK is initialized
+     */
+    isReady(): boolean;
+}
+
+interface KeverdContextValue {
+    sdk: KeverdSDK;
+    isReady: boolean;
+}
+interface KeverdProviderProps {
+    loadOptions: KeverdLoadOptions;
+    children: ReactNode;
+}
+/**
+ * KeverdProvider - Wrap your app with this component to enable Keverd SDK
+ */
+declare function KeverdProvider({ loadOptions, children }: KeverdProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access Keverd SDK from context
+ */
+declare function useKeverdContext(): KeverdContextValue;
+
+/**
+ * useKeverdVisitorData Hook
+ * React hook for accessing visitor data and risk assessment
+ */
+
+interface KeverdVisitorDataResult {
+    isLoading: boolean;
+    error: KeverdError | null;
+    data: KeverdVisitorData | null;
+    getData: (options?: KeverdVisitorDataOptions) => Promise<KeverdVisitorData>;
+}
+/**
+ * Hook to get visitor data and risk assessment
+ *
+ * @param options - Configuration options for the hook
+ * @returns Object containing loading state, error, data, and getData function
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isLoading, error, data, getData } = useKeverdVisitorData({
+ *     extendedResult: true,
+ *     immediate: true
+ *   });
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Risk Score: {data?.riskScore}</p>
+ *       <p>Action: {data?.action}</p>
+ *       <button onClick={() => getData({ ignoreCache: true })}>
+ *         Reload data
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useKeverdVisitorData(options?: KeverdVisitorDataHookOptions): KeverdVisitorDataResult;
+
+/**
+ * Keverd Device Fingerprint Collector
+ * Collects device information, canvas fingerprint, WebGL fingerprint, and generates a stable device ID
+ */
+
+declare class KeverdDeviceCollector {
+    private cachedDeviceInfo;
+    /**
+     * Collect all device information and generate fingerprint
+     */
+    collect(): KeverdDeviceInfo;
+    /**
+     * Generate a stable device fingerprint using multiple browser characteristics
+     * Returns SHA-256 hash (64 hex characters) as required by backend
+     */
+    private generateDeviceFingerprint;
+    /**
+     * Generate canvas fingerprint
+     */
+    private getCanvasFingerprint;
+    /**
+     * Generate WebGL fingerprint
+     */
+    private getWebGLFingerprint;
+    /**
+     * Generate a stable device ID from fingerprint
+     */
+    private generateDeviceId;
+    /**
+     * Get manufacturer from user agent
+     */
+    private getManufacturer;
+    /**
+     * Get model from user agent
+     */
+    private getModel;
+    /**
+     * Get brand from user agent
+     */
+    private getBrand;
+    /**
+     * Get device type
+     */
+    private getDevice;
+    /**
+     * Get product name
+     */
+    private getProduct;
+    /**
+     * Get hardware info
+     */
+    private getHardware;
+    /**
+     * Get OS version
+     */
+    private getOSVersion;
+    /**
+     * Get screen density
+     */
+    private getScreenDensity;
+    /**
+     * Hash a string using SHA-256 (required for backend compatibility)
+     * Backend expects SHA-256 hash (64 hex characters)
+     * Uses Web Crypto API synchronously via a cached approach
+     */
+    private hashString;
+    /**
+     * SHA-256-like hash function (synchronous, deterministic)
+     * Produces 64-character hex string matching SHA-256 format
+     * This is a deterministic hash that mimics SHA-256 characteristics
+     */
+    private sha256LikeHash;
+    /**
+     * Clear cached device info (useful for testing)
+     */
+    clearCache(): void;
+}
+
+/**
+ * Keverd Behavioral Data Collector
+ * Collects typing patterns, mouse movements, swipe gestures, and calculates session entropy
+ */
+
+declare class KeverdBehavioralCollector {
+    private keystrokes;
+    private mouseMovements;
+    private lastKeyDownTime;
+    private lastKeyUpTime;
+    private isActive;
+    private sessionStartTime;
+    private typingDwellTimes;
+    private typingFlightTimes;
+    private swipeVelocities;
+    private sessionEvents;
+    private touchStartPositions;
+    private keyDownHandler;
+    private keyUpHandler;
+    private mouseMoveHandler;
+    private touchStartHandler;
+    private touchEndHandler;
+    /**
+     * Start collecting behavioral data
+     */
+    start(): void;
+    /**
+     * Stop collecting behavioral data
+     */
+    stop(): void;
+    /**
+     * Get collected behavioral data
+     */
+    getData(): KeverdBehavioralData;
+    /**
+     * Reset collected data
+     */
+    reset(): void;
+    /**
+     * Handle keydown event
+     */
+    private handleKeyDown;
+    /**
+     * Handle keyup event
+     */
+    private handleKeyUp;
+    /**
+     * Handle mouse move event
+     */
+    private handleMouseMove;
+    /**
+     * Handle touch start (for swipe detection)
+     */
+    private handleTouchStart;
+    /**
+     * Handle touch end (calculate swipe velocity)
+     */
+    private handleTouchEnd;
+    /**
+     * Calculate session entropy based on event diversity
+     */
+    private calculateSessionEntropy;
+    /**
+     * Check if key should be ignored
+     */
+    private shouldIgnoreKey;
+}
+
+export { KeverdBehavioralCollector, type KeverdBehavioralData, type KeverdConfig, KeverdDeviceCollector, type KeverdDeviceInfo, type KeverdError, type KeverdFingerprintRequest, type KeverdFingerprintResponse, type KeverdLoadOptions, KeverdProvider, KeverdSDK, type KeverdSessionInfo, type KeverdSimSwapEngine, type KeverdVisitorData, type KeverdVisitorDataHookOptions, type KeverdVisitorDataOptions, type KeverdVisitorDataResult$1 as KeverdVisitorDataResult, useKeverdContext, useKeverdVisitorData };