@keverdjs/fraud-sdk-vue 1.0.0 → 2.0.0

package/dist/index.d.mts

@@ -1,65 +1,294 @@
 import { Ref, App } from 'vue';
 
 /**
- * Core SDK - placeholder
- * This will be implemented by copying from React SDK and adapting for Vue
+ * Keverd Fraud SDK Vue - Type Definitions
  */
-declare class KeverdSDK {
-}
 
-/**
- * Types for Vue SDK
- * TODO: Copy and adapt types from React SDK
- */
-interface KeverdConfig {
-    apiKey: string;
-    endpoint?: string;
-}
-interface KeverdLoadOptions {
-    apiKey: string;
-    endpoint?: string;
+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 KeverdVisitorData {
+interface KeverdSessionInfo {
+    sessionId?: string;
+    installId?: string;
+    sessionCount?: string;
+    firstSession?: string;
+    timestamp?: string;
 }
-interface KeverdVisitorDataOptions {
+interface KeverdBehavioralSequence {
+    featureNames: string[];
+    windowSize: number;
+    maskValue: number;
+    sequence: number[][];
 }
-interface KeverdVisitorDataResult {
+interface KeverdBehavioralData {
+    typing_dwell_ms?: number[];
+    typing_flight_ms?: number[];
+    swipe_velocity?: number;
+    session_entropy?: number;
+    suspicious_swipe_velocity?: number;
+    behavioral_vectors?: KeverdBehavioralSequence;
 }
 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 KeverdDeviceInfo {
+interface KeverdPrivacySignals {
+    isIncognito?: boolean;
+    isVPN?: boolean;
+    isAutomated?: boolean;
+    hasAdBlocker?: boolean;
 }
-interface KeverdSessionInfo {
+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;
+    fingerprintjsVisitorId?: string;
+    privacySignals?: KeverdPrivacySignals;
+    deviceMatch?: boolean;
+    fraudProbability?: number;
+    recommendedAction?: string;
 }
-interface KeverdBehavioralData {
+interface KeverdConfig {
+    apiKey: string;
+    userId?: string;
+    debug?: boolean;
+    extendedResult?: boolean;
+    ignoreCache?: boolean;
+}
+interface KeverdLoadOptions {
+    apiKey: string;
+    debug?: boolean;
+}
+interface KeverdVisitorDataOptions {
+    extendedResult?: boolean;
+    ignoreCache?: boolean;
+    tag?: string;
 }
 interface KeverdError {
+    message: string;
+    code?: string;
+    statusCode?: number;
+}
+interface KeverdVisitorDataResult {
+    data: Ref<KeverdVisitorData | null>;
+    loading: Ref<boolean>;
+    error: Ref<KeverdError | null>;
+    getData: () => Promise<void>;
 }
 
 /**
- * Vue composable for getting visitor data
- * TODO: Implement Vue composable
+ * Keverd Fraud SDK Core
+ * Main SDK class for fingerprinting and risk assessment
+ * Wraps the web SDK to provide Vue-specific interface with all enhanced signals
  */
 
-declare function useKeverdVisitorData(options?: KeverdVisitorDataOptions): {
-    data: Ref<KeverdVisitorDataResult | null>;
-    loading: Ref<boolean>;
-    error: Ref<Error | null>;
-    getData: () => Promise<void>;
-};
+declare class KeverdSDK {
+    private config;
+    private isInitialized;
+    constructor();
+    /**
+     * Initialize the SDK with configuration
+     * Wraps the web SDK initialization
+     */
+    init(config: KeverdConfig): void;
+    /**
+     * Get visitor data (fingerprint and risk assessment)
+     * Uses the web SDK which includes all enhanced signals including FingerprintJS
+     */
+    getVisitorData(_options?: KeverdVisitorDataOptions): Promise<KeverdVisitorData>;
+    /**
+     * Transform API response to visitor data format
+     */
+    private transformResponse;
+    /**
+     * Generate a session ID
+     */
+    private generateSessionId;
+    /**
+     * Start a new session (called automatically on init, but can be called manually)
+     */
+    startSession(userId?: string, deviceHash?: string, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * End the current session
+     */
+    endSession(): Promise<void>;
+    /**
+     * Pause the current session (e.g., when app goes to background)
+     */
+    pauseSession(): Promise<void>;
+    /**
+     * Resume a paused session (e.g., when app comes to foreground)
+     */
+    resumeSession(): Promise<void>;
+    /**
+     * Get current session status
+     */
+    getSessionStatus(): Promise<{
+        session_id: string;
+        status: string;
+        is_active: boolean;
+        is_paused: boolean;
+        event_count: number;
+        started_at: string;
+        last_activity_at: string;
+        duration_seconds: number | null;
+    } | null>;
+    /**
+     * Destroy the SDK instance
+     */
+    destroy(): Promise<void>;
+    /**
+     * Get current configuration
+     */
+    getConfig(): KeverdConfig | null;
+    /**
+     * Check if SDK is initialized
+     */
+    isReady(): boolean;
+}
 
 /**
- * Vue composable for Keverd provider
- * TODO: Implement Vue provider composable
+ * Vue composable for getting visitor data
+ * Provides reactive visitor data, loading state, and error handling
  */
 
-declare function useKeverdProvider(options: KeverdLoadOptions): void;
+interface KeverdVisitorDataHookOptions {
+    extendedResult?: boolean;
+    immediate?: boolean;
+    ignoreCache?: boolean;
+}
+/**
+ * Vue composable for accessing visitor data and risk assessment
+ *
+ * @param options - Configuration options for the hook
+ * @returns Object containing reactive data, loading state, error, and getData function
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useKeverdVisitorData } from '@keverdjs/fraud-sdk-vue';
+ *
+ * const { data, loading, error, getData } = useKeverdVisitorData({
+ *   extendedResult: true,
+ *   immediate: true
+ * });
+ * </script>
+ *
+ * <template>
+ *   <div v-if="loading">Loading...</div>
+ *   <div v-else-if="error">Error: {{ error.message }}</div>
+ *   <div v-else>
+ *     <p>Risk Score: {{ data?.riskScore }}</p>
+ *     <button @click="getData">Reload</button>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useKeverdVisitorData(options?: KeverdVisitorDataHookOptions): KeverdVisitorDataResult;
+
+/**
+ * Setup Keverd SDK provider
+ * Call this in your root component or app setup
+ */
+declare function useKeverdProvider(options: KeverdLoadOptions): {
+    sdk: Ref<{
+        init: (config: KeverdConfig) => void;
+        getVisitorData: (_options?: KeverdVisitorDataOptions) => Promise<KeverdVisitorData>;
+        startSession: (userId?: string, deviceHash?: string, metadata?: Record<string, unknown>) => Promise<void>;
+        endSession: () => Promise<void>;
+        pauseSession: () => Promise<void>;
+        resumeSession: () => Promise<void>;
+        getSessionStatus: () => Promise<{
+            session_id: string;
+            status: string;
+            is_active: boolean;
+            is_paused: boolean;
+            event_count: number;
+            started_at: string;
+            last_activity_at: string;
+            duration_seconds: number | null;
+        } | null>;
+        destroy: () => Promise<void>;
+        getConfig: () => KeverdConfig | null;
+        isReady: () => boolean;
+    } | null, KeverdSDK | {
+        init: (config: KeverdConfig) => void;
+        getVisitorData: (_options?: KeverdVisitorDataOptions) => Promise<KeverdVisitorData>;
+        startSession: (userId?: string, deviceHash?: string, metadata?: Record<string, unknown>) => Promise<void>;
+        endSession: () => Promise<void>;
+        pauseSession: () => Promise<void>;
+        resumeSession: () => Promise<void>;
+        getSessionStatus: () => Promise<{
+            session_id: string;
+            status: string;
+            is_active: boolean;
+            is_paused: boolean;
+            event_count: number;
+            started_at: string;
+            last_activity_at: string;
+            duration_seconds: number | null;
+        } | null>;
+        destroy: () => Promise<void>;
+        getConfig: () => KeverdConfig | null;
+        isReady: () => boolean;
+    } | null>;
+    isReady: Ref<boolean, boolean>;
+};
+/**
+ * Get Keverd SDK instance from context
+ * Use this in child components to access the SDK
+ */
+declare function useKeverdContext(): {
+    sdk: Ref<KeverdSDK | null>;
+    isReady: Ref<boolean>;
+};
 
 /**
  * Vue plugin for Keverd SDK
- * TODO: Implement Vue plugin
+ * Allows global installation of the SDK
  */
 
 declare const _default: {
@@ -67,17 +296,96 @@ declare const _default: {
 };
 
 /**
- * Device collector - placeholder
- * TODO: Copy from React SDK
+ * 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;
 }
 
-/**
- * Behavioral collector - placeholder
- * TODO: Copy from React SDK
- */
 declare class KeverdBehavioralCollector {
+    private isActive;
+    private sessionEvents;
+    private kinematicEngine;
+    private keystrokeMonitor;
+    constructor();
+    start(): void;
+    stop(): void;
+    reset(): void;
+    getData(): KeverdBehavioralData;
+    private buildSequence;
+    private trackEvent;
+    private calculateSessionEntropy;
 }
 
-export { KeverdBehavioralCollector, type KeverdBehavioralData, type KeverdConfig, KeverdDeviceCollector, type KeverdDeviceInfo, type KeverdError, type KeverdFingerprintRequest, type KeverdFingerprintResponse, type KeverdLoadOptions, _default as KeverdPlugin, KeverdSDK, type KeverdSessionInfo, type KeverdVisitorData, type KeverdVisitorDataOptions, type KeverdVisitorDataResult, useKeverdProvider, useKeverdVisitorData };
+export { KeverdBehavioralCollector, type KeverdBehavioralData, type KeverdConfig, KeverdDeviceCollector, type KeverdDeviceInfo, type KeverdError, type KeverdFingerprintRequest, type KeverdFingerprintResponse, type KeverdLoadOptions, _default as KeverdPlugin, KeverdSDK, type KeverdSessionInfo, type KeverdVisitorData, type KeverdVisitorDataOptions, type KeverdVisitorDataResult, useKeverdContext, useKeverdProvider, useKeverdVisitorData };