@simplr-ai/react-native 1.1.0

package/dist/flags-CwhHmaHQ.d.ts

@@ -0,0 +1,606 @@
+/**
+ * Shared types mirroring the Simplr API contract (source of truth).
+ * Keep byte-for-byte compatible with the browser/Node/Flutter SDKs.
+ */
+type RiskLevel = "low" | "medium" | "high" | "critical";
+/** Device signals collected from React Native APIs (no DOM/canvas). */
+interface DeviceSignals {
+    /** Combined stable device fingerprint hash (murmurhash3 hex). */
+    fingerprint: string;
+    /** Individual fingerprint components. */
+    fingerprint_components: {
+        device_signature: string;
+        screen_signature: string;
+        locale_signature: string;
+    };
+    /** Persistent device ID (AsyncStorage-backed when available). */
+    device_id: string;
+    /** When the device ID was first created (ISO 8601), or null. */
+    device_id_created_at: string | null;
+    /** Platform type. */
+    platform: "ios" | "android";
+    /** Operating system name. */
+    os: string;
+    os_version: string | null;
+    /** Device model / brand if obtainable. */
+    model: string | null;
+    brand: string | null;
+    /** Screen geometry. */
+    screen_resolution: string;
+    device_pixel_ratio: number;
+    font_scale: number;
+    /** Timezone. */
+    timezone: string;
+    timezone_offset: number;
+    /** Locale. */
+    language: string;
+    languages: string[];
+    /** Whether the device is recognized as a physical phone/tablet (vs simulator). */
+    is_emulator: boolean | null;
+}
+interface TouchMetrics {
+    /** Average touch pressure (0-1), when the platform reports force. */
+    avgPressure: number;
+    /** Standard deviation of touch pressure. */
+    pressureStdDev: number;
+    /** Average swipe velocity (px/s). */
+    avgSwipeVelocity: number;
+    /** Number of touch sample points. */
+    touchCount: number;
+    /** Number of tap (touch-end) gestures. */
+    tapCount: number;
+    /** Average interval between consecutive taps (ms). */
+    avgTapInterval: number;
+    /** Standard deviation of tap intervals (ms). */
+    tapIntervalStdDev: number;
+    /** Average duration a touch was held (ms). */
+    avgTouchDuration: number;
+    /** Number of multi-touch gestures. */
+    multiTouchCount: number;
+    /** Total tracking duration (ms). */
+    totalDuration: number;
+}
+interface BehaviorSignals {
+    touch?: TouchMetrics;
+    /** Time the user spent on the current form/screen (ms). */
+    form_fill_time?: number;
+}
+interface CollectedSignals {
+    device: DeviceSignals;
+    behavior: BehaviorSignals;
+    collected_at: string;
+}
+/** POST /v1/check input. */
+interface CheckInput {
+    email?: string;
+    phone?: string;
+    device?: Record<string, unknown>;
+    behavior?: Record<string, unknown>;
+    event_type?: string;
+    event_id?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/** POST /v1/check result. */
+interface CheckResult {
+    type?: string;
+    risk_score: number;
+    risk_level: RiskLevel;
+    signals?: Record<string, unknown>;
+    email?: string;
+    phone_number?: string;
+    fingerprint_hash?: string;
+    checked_at?: string;
+    is_sandbox?: boolean;
+    [key: string]: unknown;
+}
+/** POST /v1/orders input. */
+interface OrderInput {
+    order_id: string;
+    external_id?: string;
+    amount: number;
+    currency: string;
+    fingerprint_hash?: string;
+    [key: string]: unknown;
+}
+/** POST /v1/orders result. */
+interface OrderResult {
+    order_id: string;
+    risk_score: number;
+    risk_level: RiskLevel;
+    [key: string]: unknown;
+}
+/** Feature-flag rule (contract). */
+interface FlagRule {
+    attribute: string;
+    op: "eq" | "neq" | "contains";
+    value: string;
+}
+/** Feature-flag definition (contract). */
+interface FlagDefinition {
+    key: string;
+    enabled: boolean;
+    rollout_percentage: number;
+    target_user_ids: string[];
+    rules: FlagRule[];
+}
+interface EvalContext {
+    userId?: string;
+    attributes?: Record<string, unknown>;
+}
+interface IdentifyOptions {
+    /** Profile type. */
+    profileType?: "customer" | "cashier" | "employee";
+    /** Pre-collected device signals (auto-collected if omitted). */
+    deviceSignals?: DeviceSignals;
+    /** Extra fields merged into the request body. */
+    [key: string]: unknown;
+}
+interface ProfileResult {
+    profile: {
+        id: string;
+        external_id: string;
+        profile_type: string;
+        status: string;
+        risk_score: number;
+        risk_level: string;
+        device_count: number;
+        total_orders: number;
+        first_seen_at: string;
+        last_seen_at: string;
+    };
+    is_new: boolean;
+    device_linked: boolean;
+    device_anomaly?: string;
+    [key: string]: unknown;
+}
+interface ProfileRiskResult {
+    profile: {
+        id: string;
+        external_id: string;
+        profile_type: string;
+        status: string;
+        risk_score: number;
+        risk_level: string;
+        signals: Record<string, number>;
+        device_count: number;
+        total_orders: number;
+        flagged_orders: number;
+        fraud_reports: number;
+        legitimate_reports: number;
+        first_seen_at: string;
+        last_seen_at: string;
+    };
+    [key: string]: unknown;
+}
+type RUMEventType = "session_start" | "session_end" | "view" | "action" | "error" | "log";
+type RUMLogLevel = "debug" | "info" | "warn" | "error";
+interface RUMEvent {
+    type: RUMEventType;
+    timestamp: number;
+    sessionId: string;
+    viewId?: string;
+    userId?: string;
+    applicationId: string;
+    applicationVersion?: string;
+    environment?: string;
+    platform?: string;
+    view?: {
+        id: string;
+        name: string;
+    };
+    action?: {
+        name: string;
+        type: string;
+    };
+    error?: {
+        message: string;
+        stack?: string;
+        type?: string;
+    };
+    log?: {
+        level: RUMLogLevel;
+        message: string;
+    };
+    attributes?: Record<string, unknown>;
+    userAttributes?: Record<string, unknown>;
+    globalAttributes?: Record<string, unknown>;
+}
+interface RUMEventBatch {
+    events: RUMEvent[];
+    sentAt: number;
+}
+type BindingMode = "verified_device" | "any_location";
+interface CreateDelegationOptions {
+    userId: string;
+    email?: string;
+    binding?: BindingMode;
+    expiresInDays?: number;
+    sessionId?: string;
+    fingerprintHash?: string;
+}
+interface DelegationResult {
+    token: string;
+    delegationId: string;
+    expiresAt: string;
+    bindingMode: BindingMode;
+}
+interface DelegationInfo {
+    delegationId: string;
+    endUserId: string;
+    bindingMode: BindingMode;
+    status: "active" | "revoked" | "expired";
+    expiresAt: string;
+    useCount: number;
+    lastUsedAt?: string;
+    createdAt: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    sessionType?: "ai";
+    endUserId?: string;
+    delegation?: {
+        delegationId: string;
+        bindingMode: BindingMode;
+        expiresAt: string;
+        useCount: number;
+    };
+    error?: string;
+}
+interface DelegationStats {
+    totalDelegations: number;
+    activeDelegations: number;
+    totalUses: number;
+    delegationsByBinding: {
+        verifiedDevice: number;
+        anyLocation: number;
+    };
+}
+
+/**
+ * Touch / gesture dynamics tracker for React Native.
+ *
+ * Pure JS, analogous to the browser touch tracker but fed by handlers the
+ * developer attaches to RN gesture responders (PanResponder / onTouch* props).
+ * It records tap intervals, touch pressure/force (when reported), swipe
+ * velocity and touch durations, then derives stable behavioral metrics.
+ */
+
+/** A single touch sample. Shaped to accept RN GestureResponderEvent fields. */
+interface TouchSample {
+    x: number;
+    y: number;
+    timestamp: number;
+    /** Pressure/force 0..1 (iOS 3D-touch / pencil); 0 when unreported. */
+    force?: number;
+}
+/** Subset of an RN GestureResponderEvent we read from. */
+interface RNTouchEventLike {
+    nativeEvent?: {
+        locationX?: number;
+        locationY?: number;
+        pageX?: number;
+        pageY?: number;
+        force?: number;
+        timestamp?: number;
+        touches?: unknown[];
+    };
+}
+declare class TouchTracker {
+    private samples;
+    private touchDurations;
+    private tapTimestamps;
+    private activeStart;
+    private multiTouchCount;
+    private startTime;
+    private tracking;
+    start(): void;
+    stop(): void;
+    reset(): void;
+    private extract;
+    /** Call on touch/gesture start (e.g. onResponderGrant / onTouchStart). */
+    handleTouchStart(e: RNTouchEventLike): void;
+    /** Call on touch/gesture move (e.g. onResponderMove / onTouchMove). */
+    handleTouchMove(e: RNTouchEventLike): void;
+    /** Call on touch/gesture end (e.g. onResponderRelease / onTouchEnd). */
+    handleTouchEnd(e: RNTouchEventLike): void;
+    /** Handlers ready to spread onto a View's responder/touch props. */
+    getEventHandlers(): {
+        onTouchStart: (e: RNTouchEventLike) => void;
+        onTouchMove: (e: RNTouchEventLike) => void;
+        onTouchEnd: (e: RNTouchEventLike) => void;
+    };
+    getMetrics(): TouchMetrics;
+    getRawData(): TouchSample[];
+}
+declare function createTouchTracker(): TouchTracker;
+
+/**
+ * Anonymous user profile management + order fraud monitoring for React Native.
+ *
+ * Configure with a PUBLIC key (pk_…). Ported from the browser SimplrProfiles,
+ * but reuses the RN http helper (which sends `X-API-Key` and unwraps the
+ * `{ success, message, content }` envelope) and the shared SimplrError.
+ */
+
+interface SimplrProfilesConfig {
+    /** Public API key (pk_*). */
+    apiKey: string;
+    /** API base URL (default https://api.simplr.sh). */
+    baseUrl?: string;
+    /** Per-request timeout in ms (default 15000). */
+    timeoutMs?: number;
+    /** Override fetch (defaults to the RN/global fetch). */
+    fetchImpl?: typeof fetch;
+}
+declare class SimplrProfiles {
+    private apiKey;
+    private baseUrl;
+    private timeoutMs;
+    private fetchImpl?;
+    private collectDeviceSignalsFn?;
+    private configured;
+    constructor(config?: SimplrProfilesConfig);
+    configure(config: SimplrProfilesConfig): this;
+    /**
+     * Set the device-signal collector so identify()/submitOrder() can auto-attach
+     * a fingerprint. The main client wires this to its own collector.
+     */
+    setDeviceSignalCollector(fn: () => Promise<DeviceSignals>): void;
+    private requireConfigured;
+    private get httpConfig();
+    /** Create or update an anonymous profile and link the current device. */
+    identify(externalId: string, options?: IdentifyOptions): Promise<ProfileResult>;
+    /** Submit an order for real-time fraud scoring; auto-attaches a fingerprint. */
+    submitOrder(order: OrderInput): Promise<OrderResult>;
+    /** Get the risk profile for a user. */
+    getProfileRisk(externalId: string): Promise<ProfileRiskResult>;
+    /** Report a profile as fraud or legitimate. */
+    reportOutcome(externalId: string, outcome: "fraud" | "legitimate"): Promise<void>;
+}
+/** Convenience singleton. */
+declare const simplrProfiles: SimplrProfiles;
+
+/**
+ * SimplrRUM — Real User Monitoring for React Native.
+ *
+ * Configure with a PUBLIC key (pk_…). Batches events and flushes them to
+ * POST /v1/rum/events using a timer-based flush (setInterval). There are no
+ * native dependencies — screen views are captured via the public trackView()
+ * API the developer calls (or the useTrackView hook). Reuses the RN http helper
+ * (`X-API-Key` + envelope unwrapping) and the shared SimplrError.
+ */
+
+interface SimplrRUMConfig {
+    /** Public API key (pk_*). */
+    apiKey: string;
+    /** Application identifier (required). */
+    applicationId: string;
+    /** Optional version/environment tags applied to every event. */
+    applicationVersion?: string;
+    environment?: string;
+    /** API base URL (default https://api.simplr.sh). */
+    baseUrl?: string;
+    /** Flush when this many events are queued (default 30). */
+    batchSize?: number;
+    /** Background flush interval in ms (default 10000; 0 disables the timer). */
+    flushInterval?: number;
+    /** Per-request timeout in ms (default 15000). */
+    timeoutMs?: number;
+    /** Override fetch (defaults to the RN/global fetch). */
+    fetchImpl?: typeof fetch;
+}
+declare class SimplrRUM {
+    private config;
+    private initialized;
+    private baseUrl;
+    private timeoutMs;
+    private fetchImpl?;
+    private batchSize;
+    private queue;
+    private timer;
+    private flushing;
+    private sessionId;
+    private currentViewId;
+    private userId?;
+    private userAttributes?;
+    private globalAttributes;
+    /** Initialize the SDK, start a session, and begin the flush timer. */
+    initialize(config: SimplrRUMConfig): void;
+    isInitialized(): boolean;
+    private get httpConfig();
+    /** Associate subsequent events with a user. */
+    setUser(userId: string, attributes?: Record<string, unknown>): void;
+    clearUser(): void;
+    addAttribute(key: string, value: unknown): void;
+    removeAttribute(key: string): void;
+    /** Track a screen view (call from your navigation listener or useTrackView). */
+    trackView(name: string, attributes?: Record<string, unknown>): void;
+    /** Track a user action (tap, swipe, submit, …). */
+    trackAction(name: string, attributes?: Record<string, unknown>): void;
+    /** Track an error. */
+    trackError(error: Error | {
+        message: string;
+        stack?: string;
+        type?: string;
+    }, attributes?: Record<string, unknown>): void;
+    /** Emit a log line. */
+    log(level: RUMLogLevel, message: string, attributes?: Record<string, unknown>): void;
+    private trackEvent;
+    /** Flush queued events to POST /v1/rum/events. */
+    flush(): Promise<void>;
+    /** End the session, flush remaining events, and stop the timer. */
+    stopSession(): Promise<void>;
+    getSessionId(): string | null;
+    getViewId(): string | null;
+}
+/** Convenience singleton. */
+declare const simplrRUM: SimplrRUM;
+
+/**
+ * AI delegation (SimplrAI) for React Native — OAuth-like AI authentication.
+ *
+ * Configure with a PUBLIC key (pk_…). Mint, validate, and revoke delegation
+ * tokens an end user shares with their AI agent. Reuses the RN http helper
+ * (`X-API-Key` + envelope unwrapping) and the shared SimplrError.
+ *
+ * The browser SDK's interactive `connect()` popup is browser-only (uses
+ * window.open / postMessage) and is intentionally omitted here — use
+ * createDelegation() to mint tokens directly.
+ */
+
+interface SimplrAIConfig {
+    /** API key (public pk_* for clients). */
+    apiKey: string;
+    /** API base URL (default https://api.simplr.sh). */
+    baseUrl?: string;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}
+declare class SimplrAI {
+    private apiKey;
+    private baseUrl;
+    private timeoutMs;
+    private fetchImpl?;
+    private configured;
+    constructor(config?: SimplrAIConfig);
+    configure(config: SimplrAIConfig): this;
+    private requireConfigured;
+    private get httpConfig();
+    /** Create a new AI delegation token for a user. POST /v1/ai/delegations. */
+    createDelegation(options: CreateDelegationOptions): Promise<DelegationResult>;
+    /** Validate (introspect) an AI delegation token. POST /v1/ai/validate. */
+    validate(token: string, options?: {
+        fingerprintHash?: string;
+        aiProvider?: string;
+        action?: string;
+    }): Promise<ValidationResult>;
+    /** Revoke a delegation. POST /v1/ai/delegations/{id}/revoke. */
+    revoke(delegationId: string, reason?: string): Promise<void>;
+    /** List delegations, optionally filtered by user. GET /v1/ai/delegations. */
+    list(userId?: string): Promise<DelegationInfo[]>;
+    /** Get a single delegation. GET /v1/ai/delegations/{id}. */
+    get(delegationId: string): Promise<DelegationInfo>;
+    /** Get delegation statistics. GET /v1/ai/stats. */
+    stats(): Promise<DelegationStats>;
+    /** Revoke all delegations for a user (e.g. on logout). POST /v1/ai/revoke-all. */
+    revokeAllForUser(userId: string, reason?: string): Promise<number>;
+}
+/** Convenience singleton. */
+declare const simplrAI: SimplrAI;
+
+/**
+ * SimplrFraud — the React Native client surface.
+ *
+ * Configure with a PUBLIC key (pk_…), collect device signals, run fraud checks
+ * (POST /v1/check), submit orders (POST /v1/orders), and optionally identify
+ * profiles. Uses the global fetch (available in React Native).
+ */
+
+interface SimplrFraudConfig {
+    /** Public API key (pk_live_… / pk_test_…). Safe for client use. */
+    apiKey: string;
+    /** API base URL (default https://api.simplr.sh). Trailing slashes stripped. */
+    baseUrl?: string;
+    /** Per-request timeout in ms (default 15000). */
+    timeoutMs?: number;
+    /** Begin collecting touch biometrics immediately (default true). */
+    autoStart?: boolean;
+    /** Override fetch (defaults to the RN/global fetch). */
+    fetchImpl?: typeof fetch;
+}
+declare class SimplrFraud {
+    private apiKey;
+    private baseUrl;
+    private timeoutMs;
+    private fetchImpl?;
+    private touchTracker;
+    private formStartTime;
+    private configured;
+    /** Anonymous user profiles + order fraud monitoring (shares this client's config). */
+    readonly profiles: SimplrProfiles;
+    /** Real User Monitoring — batched events to /v1/rum/events. */
+    readonly rum: SimplrRUM;
+    /** AI delegation — OAuth-like AI authentication. */
+    readonly ai: SimplrAI;
+    constructor(config?: SimplrFraudConfig);
+    /** Configure (or re-configure) the client. */
+    configure(config: SimplrFraudConfig): this;
+    private requireConfigured;
+    private get httpConfig();
+    /** Start collecting touch biometrics and reset the form timer. */
+    startTracking(): void;
+    stopTracking(): void;
+    reset(): void;
+    /** The shared touch tracker; attach its handlers to your Views. */
+    getTouchTracker(): TouchTracker;
+    collectBehaviorSignals(): BehaviorSignals;
+    /** Collect stable device signals from React Native APIs. */
+    getDeviceSignals(): Promise<DeviceSignals>;
+    /** Collect device + behavior signals together. */
+    collect(): Promise<CollectedSignals>;
+    /**
+     * Run a fraud check. Device + behavior signals are auto-collected and merged
+     * into the request unless already present on `input`.
+     */
+    check(input?: CheckInput): Promise<CheckResult>;
+    /** Submit an order for scoring (POST /v1/orders). */
+    submitOrder(order: OrderInput): Promise<OrderResult>;
+    /**
+     * Identify/associate the current device with an external profile id.
+     * Sends a profile check via POST /v1/check with the device signals attached.
+     */
+    identify(externalId: string, metadata?: Record<string, unknown>): Promise<CheckResult>;
+}
+/** Convenience singleton for simple apps. */
+declare const simplr: SimplrFraud;
+
+/**
+ * Feature flags with deterministic per-user rollout + targeting.
+ *
+ * Ported from @simplr-ai/js. Flags are fetched once from
+ * GET /v1/flags (public key) and refreshed on an interval, then evaluated
+ * locally — no network call per `isEnabled`. Bucketing uses the verbatim
+ * murmurHash3 port so it matches the server/browser/Node/Flutter exactly.
+ */
+
+interface SimplrFlagsConfig {
+    /** Public API key (pk_*). */
+    apiKey: string;
+    /** API base URL (default https://api.simplr.sh). */
+    baseUrl?: string;
+    /** Which key environment's flags to load (default: test). */
+    environment?: "live" | "test";
+    /** Auto-refresh interval in ms (default 60000; 0 disables). */
+    refreshIntervalMs?: number;
+    /** Fallback identity used when no userId is supplied (e.g. device_id). */
+    defaultUserId?: string;
+    /** Override fetch (defaults to global fetch). */
+    fetchImpl?: typeof fetch;
+}
+declare class SimplrFlags {
+    private apiKey;
+    private baseUrl;
+    private environment;
+    private refreshIntervalMs;
+    private flags;
+    private userId?;
+    private defaultUserId?;
+    private fetchImpl?;
+    private timer;
+    private ready;
+    initialize(config: SimplrFlagsConfig): Promise<void>;
+    setUser(userId: string): void;
+    /** Sets the fallback identity (typically the persisted device_id). */
+    setDefaultUser(userId: string): void;
+    refresh(): Promise<void>;
+    isEnabled(key: string, ctx?: EvalContext): boolean;
+    getAll(): Record<string, FlagDefinition>;
+    /** Replace the in-memory flag set directly (useful for testing/SSR). */
+    setFlags(list: FlagDefinition[]): void;
+    isReady(): boolean;
+    dispose(): void;
+}
+declare const simplrFlags: SimplrFlags;
+
+export { simplr as A, type BehaviorSignals as B, type CheckInput as C, type DeviceSignals as D, type EvalContext as E, type FlagDefinition as F, simplrAI as G, simplrFlags as H, type IdentifyOptions as I, simplrProfiles as J, simplrRUM as K, type OrderInput as O, type ProfileResult as P, type RUMEvent as R, SimplrFraud as S, TouchTracker as T, type ValidationResult as V, SimplrFlags as a, type SimplrRUMConfig as b, SimplrRUM as c, type SimplrFraudConfig as d, type BindingMode as e, type CheckResult as f, type CollectedSignals as g, type CreateDelegationOptions as h, type DelegationInfo as i, type DelegationResult as j, type DelegationStats as k, type FlagRule as l, type OrderResult as m, type ProfileRiskResult as n, type RUMEventBatch as o, type RUMEventType as p, type RUMLogLevel as q, type RiskLevel as r, SimplrAI as s, type SimplrAIConfig as t, type SimplrFlagsConfig as u, SimplrProfiles as v, type SimplrProfilesConfig as w, type TouchMetrics as x, type TouchSample as y, createTouchTracker as z };