@switchlabs/verify-ai-react-native 0.1.0

package/lib/client/index.d.ts

@@ -0,0 +1,62 @@
+import type { VerifyAIConfig, VerificationRequest, VerificationResult, VerificationListResponse, VerificationListParams, VerifyAIError } from '../types';
+export declare class VerifyAIClient {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    constructor(config: VerifyAIConfig);
+    private request;
+    /**
+     * Submit a photo for AI verification.
+     *
+     * @param request - The verification request with base64 image and policy
+     * @returns The verification result with compliance status and feedback
+     *
+     * @example
+     * ```typescript
+     * const result = await client.verify({
+     *   image: base64ImageData,
+     *   policy: 'scooter_parking',
+     *   metadata: { device_id: 'dev_123', gps: { lat: 37.77, lng: -122.42 } },
+     * });
+     *
+     * if (result.is_compliant) {
+     *   console.log('Parking approved!');
+     * } else {
+     *   console.log('Issues:', result.violation_reasons);
+     *   console.log('Feedback:', result.feedback);
+     * }
+     * ```
+     */
+    verify(request: VerificationRequest): Promise<VerificationResult>;
+    /**
+     * List past verifications with optional filters.
+     *
+     * @param params - Pagination and filter parameters
+     * @returns Paginated list of verification results
+     *
+     * @example
+     * ```typescript
+     * const { data, has_more, next_cursor } = await client.listVerifications({
+     *   limit: 20,
+     *   policy: 'scooter_parking',
+     *   is_compliant: false,
+     * });
+     * ```
+     */
+    listVerifications(params?: VerificationListParams): Promise<VerificationListResponse>;
+    /**
+     * Get a single verification by ID.
+     *
+     * @param id - The verification ID (e.g., "ver_8x92m4k9")
+     * @returns The full verification result with a fresh signed image URL
+     */
+    getVerification(id: string): Promise<VerificationResult>;
+}
+export declare class VerifyAIRequestError extends Error {
+    status: number;
+    body: VerifyAIError;
+    constructor(message: string, status: number, body: VerifyAIError);
+    get isRateLimited(): boolean;
+    get isUnauthorized(): boolean;
+    get upgradeUrl(): string | undefined;
+}

package/lib/client/index.js

@@ -0,0 +1,124 @@
+const DEFAULT_BASE_URL = 'https://verify.switchlabs.dev/api/v1';
+const DEFAULT_TIMEOUT = 30000;
+export class VerifyAIClient {
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error('VerifyAI: apiKey is required');
+        }
+        this.apiKey = config.apiKey;
+        this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, '');
+        this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    }
+    async request(path, options = {}) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.baseUrl}${path}`, {
+                ...options,
+                signal: controller.signal,
+                headers: {
+                    'X-API-Key': this.apiKey,
+                    ...options.headers,
+                },
+            });
+            const body = await response.json();
+            if (!response.ok) {
+                const error = body;
+                throw new VerifyAIRequestError(error.error || `Request failed with status ${response.status}`, response.status, error);
+            }
+            return body;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * Submit a photo for AI verification.
+     *
+     * @param request - The verification request with base64 image and policy
+     * @returns The verification result with compliance status and feedback
+     *
+     * @example
+     * ```typescript
+     * const result = await client.verify({
+     *   image: base64ImageData,
+     *   policy: 'scooter_parking',
+     *   metadata: { device_id: 'dev_123', gps: { lat: 37.77, lng: -122.42 } },
+     * });
+     *
+     * if (result.is_compliant) {
+     *   console.log('Parking approved!');
+     * } else {
+     *   console.log('Issues:', result.violation_reasons);
+     *   console.log('Feedback:', result.feedback);
+     * }
+     * ```
+     */
+    async verify(request) {
+        return this.request('/verify', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+        });
+    }
+    /**
+     * List past verifications with optional filters.
+     *
+     * @param params - Pagination and filter parameters
+     * @returns Paginated list of verification results
+     *
+     * @example
+     * ```typescript
+     * const { data, has_more, next_cursor } = await client.listVerifications({
+     *   limit: 20,
+     *   policy: 'scooter_parking',
+     *   is_compliant: false,
+     * });
+     * ```
+     */
+    async listVerifications(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.limit)
+            searchParams.set('limit', String(params.limit));
+        if (params.cursor)
+            searchParams.set('cursor', params.cursor);
+        if (params.policy)
+            searchParams.set('policy', params.policy);
+        if (params.status)
+            searchParams.set('status', params.status);
+        if (params.is_compliant !== undefined)
+            searchParams.set('is_compliant', String(params.is_compliant));
+        if (params.start_date)
+            searchParams.set('start_date', params.start_date);
+        if (params.end_date)
+            searchParams.set('end_date', params.end_date);
+        const qs = searchParams.toString();
+        return this.request(`/verifications${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * Get a single verification by ID.
+     *
+     * @param id - The verification ID (e.g., "ver_8x92m4k9")
+     * @returns The full verification result with a fresh signed image URL
+     */
+    async getVerification(id) {
+        return this.request(`/verifications/${id}`);
+    }
+}
+export class VerifyAIRequestError extends Error {
+    constructor(message, status, body) {
+        super(message);
+        this.name = 'VerifyAIRequestError';
+        this.status = status;
+        this.body = body;
+    }
+    get isRateLimited() {
+        return this.status === 429;
+    }
+    get isUnauthorized() {
+        return this.status === 401;
+    }
+    get upgradeUrl() {
+        return this.body.upgrade_url;
+    }
+}

package/lib/components/VerifyAIScanner.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+import { type ViewStyle } from 'react-native';
+import type { VerificationResult, ScannerOverlayConfig } from '../types';
+export interface VerifyAIScannerProps {
+    /** Called with the base64 image data when the user captures a photo. */
+    onCapture: (base64Image: string) => Promise<VerificationResult | null>;
+    /** Called when verification completes successfully. */
+    onResult?: (result: VerificationResult) => void;
+    /** Called when an error occurs. */
+    onError?: (error: Error) => void;
+    /** Overlay configuration for the camera view. */
+    overlay?: ScannerOverlayConfig;
+    /** Custom style for the container. */
+    style?: ViewStyle;
+    /** Whether to show the default capture button. Set false to use your own. */
+    showCaptureButton?: boolean;
+    /** Ref to imperatively trigger capture from parent. */
+    captureRef?: React.MutableRefObject<(() => void) | null>;
+}
+/**
+ * Camera scanner component for capturing verification photos.
+ * Uses expo-camera for the camera view and provides a simple capture UI.
+ *
+ * @example
+ * ```tsx
+ * const { verify } = useVerifyAI({ apiKey: 'vai_...' });
+ *
+ * <VerifyAIScanner
+ *   onCapture={(base64) => verify({ image: base64, policy: 'scooter_parking' })}
+ *   onResult={(result) => {
+ *     if (result.is_compliant) navigation.navigate('Success');
+ *   }}
+ *   overlay={{
+ *     title: 'Photo Verification',
+ *     instructions: 'Center the scooter in the frame',
+ *     showGuideFrame: true,
+ *   }}
+ * />
+ * ```
+ */
+export declare function VerifyAIScanner({ onCapture, onResult, onError, overlay, style, showCaptureButton, captureRef, }: VerifyAIScannerProps): import("react/jsx-runtime").JSX.Element;

package/lib/components/VerifyAIScanner.js

@@ -0,0 +1,222 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useState, useCallback } from 'react';
+import { View, Text, TouchableOpacity, StyleSheet, ActivityIndicator, } from 'react-native';
+import { CameraView, useCameraPermissions, } from 'expo-camera';
+/**
+ * Camera scanner component for capturing verification photos.
+ * Uses expo-camera for the camera view and provides a simple capture UI.
+ *
+ * @example
+ * ```tsx
+ * const { verify } = useVerifyAI({ apiKey: 'vai_...' });
+ *
+ * <VerifyAIScanner
+ *   onCapture={(base64) => verify({ image: base64, policy: 'scooter_parking' })}
+ *   onResult={(result) => {
+ *     if (result.is_compliant) navigation.navigate('Success');
+ *   }}
+ *   overlay={{
+ *     title: 'Photo Verification',
+ *     instructions: 'Center the scooter in the frame',
+ *     showGuideFrame: true,
+ *   }}
+ * />
+ * ```
+ */
+export function VerifyAIScanner({ onCapture, onResult, onError, overlay, style, showCaptureButton = true, captureRef, }) {
+    const cameraRef = useRef(null);
+    const [status, setStatus] = useState('idle');
+    const [result, setResult] = useState(null);
+    const [permission, requestPermission] = useCameraPermissions();
+    const handleCapture = useCallback(async () => {
+        if (!cameraRef.current || status === 'capturing' || status === 'processing')
+            return;
+        setStatus('capturing');
+        setResult(null);
+        try {
+            const photo = await cameraRef.current.takePictureAsync({
+                base64: true,
+                quality: 0.8,
+                exif: false,
+            });
+            if (!photo?.base64) {
+                throw new Error('Failed to capture photo');
+            }
+            setStatus('processing');
+            const verificationResult = await onCapture(photo.base64);
+            if (verificationResult) {
+                setResult(verificationResult);
+                setStatus('success');
+                onResult?.(verificationResult);
+            }
+            else {
+                // null result means queued for offline
+                setStatus('idle');
+            }
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            setStatus('error');
+            onError?.(error);
+            // Reset after a brief pause
+            setTimeout(() => setStatus('idle'), 2000);
+        }
+    }, [status, onCapture, onResult, onError]);
+    // Expose capture to parent via ref
+    if (captureRef) {
+        captureRef.current = handleCapture;
+    }
+    if (!permission) {
+        return _jsx(View, { style: [styles.container, style] });
+    }
+    if (!permission.granted) {
+        return (_jsxs(View, { style: [styles.container, styles.permissionContainer, style], children: [_jsx(Text, { style: styles.permissionText, children: "Camera access is required for photo verification" }), _jsx(TouchableOpacity, { style: styles.permissionButton, onPress: requestPermission, children: _jsx(Text, { style: styles.permissionButtonText, children: "Grant Camera Access" }) })] }));
+    }
+    return (_jsx(View, { style: [styles.container, style], children: _jsxs(CameraView, { ref: cameraRef, style: styles.camera, facing: "back", children: [_jsxs(View, { style: styles.overlay, children: [overlay?.title && (_jsx(View, { style: styles.topBar, children: _jsx(Text, { style: styles.titleText, children: overlay.title }) })), overlay?.showGuideFrame && (_jsx(View, { style: styles.guideContainer, children: _jsx(View, { style: [
+                                    styles.guideFrame,
+                                    overlay.guideFrameAspectRatio
+                                        ? { aspectRatio: overlay.guideFrameAspectRatio }
+                                        : undefined,
+                                ] }) })), overlay?.instructions && status === 'idle' && (_jsx(View, { style: styles.instructionsContainer, children: _jsx(Text, { style: styles.instructionsText, children: overlay.instructions }) })), status === 'processing' && (_jsxs(View, { style: styles.statusOverlay, children: [_jsx(ActivityIndicator, { size: "large", color: "#fff" }), _jsx(Text, { style: styles.statusText, children: "Analyzing photo..." })] })), status === 'success' && result && (_jsxs(View, { style: styles.statusOverlay, children: [_jsx(View, { style: [
+                                        styles.resultBadge,
+                                        result.is_compliant ? styles.resultPass : styles.resultFail,
+                                    ], children: _jsx(Text, { style: styles.resultText, children: result.is_compliant ? 'PASS' : 'FAIL' }) }), _jsx(Text, { style: styles.feedbackText, children: result.feedback })] })), status === 'error' && (_jsx(View, { style: styles.statusOverlay, children: _jsx(Text, { style: styles.errorText, children: "Verification failed. Try again." }) }))] }), showCaptureButton && (_jsx(View, { style: styles.bottomBar, children: _jsx(TouchableOpacity, { style: [
+                            styles.captureButton,
+                            (status === 'capturing' || status === 'processing') && styles.captureButtonDisabled,
+                        ], onPress: handleCapture, disabled: status === 'capturing' || status === 'processing', activeOpacity: 0.7, children: _jsx(View, { style: styles.captureButtonInner }) }) }))] }) }));
+}
+const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+        backgroundColor: '#000',
+    },
+    camera: {
+        flex: 1,
+    },
+    overlay: {
+        ...StyleSheet.absoluteFillObject,
+        justifyContent: 'space-between',
+    },
+    topBar: {
+        paddingTop: 60,
+        paddingHorizontal: 20,
+        alignItems: 'center',
+    },
+    titleText: {
+        color: '#fff',
+        fontSize: 18,
+        fontWeight: '600',
+    },
+    guideContainer: {
+        flex: 1,
+        justifyContent: 'center',
+        alignItems: 'center',
+        paddingHorizontal: 40,
+    },
+    guideFrame: {
+        width: '100%',
+        aspectRatio: 4 / 3,
+        borderWidth: 2,
+        borderColor: 'rgba(255, 255, 255, 0.5)',
+        borderRadius: 12,
+        borderStyle: 'dashed',
+    },
+    instructionsContainer: {
+        paddingHorizontal: 20,
+        paddingBottom: 20,
+        alignItems: 'center',
+    },
+    instructionsText: {
+        color: 'rgba(255, 255, 255, 0.8)',
+        fontSize: 14,
+        textAlign: 'center',
+    },
+    statusOverlay: {
+        ...StyleSheet.absoluteFillObject,
+        backgroundColor: 'rgba(0, 0, 0, 0.6)',
+        justifyContent: 'center',
+        alignItems: 'center',
+        gap: 16,
+    },
+    statusText: {
+        color: '#fff',
+        fontSize: 16,
+        fontWeight: '500',
+    },
+    resultBadge: {
+        paddingHorizontal: 24,
+        paddingVertical: 12,
+        borderRadius: 8,
+    },
+    resultPass: {
+        backgroundColor: 'rgba(34, 197, 94, 0.9)',
+    },
+    resultFail: {
+        backgroundColor: 'rgba(239, 68, 68, 0.9)',
+    },
+    resultText: {
+        color: '#fff',
+        fontSize: 24,
+        fontWeight: '700',
+    },
+    feedbackText: {
+        color: '#fff',
+        fontSize: 14,
+        textAlign: 'center',
+        paddingHorizontal: 40,
+        lineHeight: 20,
+    },
+    errorText: {
+        color: '#ef4444',
+        fontSize: 16,
+        fontWeight: '500',
+    },
+    bottomBar: {
+        position: 'absolute',
+        bottom: 40,
+        left: 0,
+        right: 0,
+        alignItems: 'center',
+    },
+    captureButton: {
+        width: 72,
+        height: 72,
+        borderRadius: 36,
+        borderWidth: 4,
+        borderColor: '#fff',
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    captureButtonDisabled: {
+        opacity: 0.4,
+    },
+    captureButtonInner: {
+        width: 58,
+        height: 58,
+        borderRadius: 29,
+        backgroundColor: '#fff',
+    },
+    permissionContainer: {
+        justifyContent: 'center',
+        alignItems: 'center',
+        paddingHorizontal: 40,
+        gap: 20,
+    },
+    permissionText: {
+        color: '#fff',
+        fontSize: 16,
+        textAlign: 'center',
+        lineHeight: 24,
+    },
+    permissionButton: {
+        backgroundColor: '#3b82f6',
+        paddingHorizontal: 24,
+        paddingVertical: 12,
+        borderRadius: 8,
+    },
+    permissionButtonText: {
+        color: '#fff',
+        fontSize: 16,
+        fontWeight: '600',
+    },
+});

package/lib/hooks/useVerifyAI.d.ts

@@ -0,0 +1,48 @@
+import { VerifyAIClient } from '../client';
+import { OfflineQueue } from '../storage/offlineQueue';
+import type { VerifyAIConfig, VerificationRequest, VerificationResult, VerificationListParams, VerificationListResponse } from '../types';
+export interface UseVerifyAIReturn {
+    /** Submit a verification. Uses offline queue if offlineMode is enabled and request fails. */
+    verify: (request: VerificationRequest) => Promise<VerificationResult | null>;
+    /** List past verifications. */
+    listVerifications: (params?: VerificationListParams) => Promise<VerificationListResponse>;
+    /** Get a single verification by ID. */
+    getVerification: (id: string) => Promise<VerificationResult>;
+    /** Whether a verification is currently in progress. */
+    loading: boolean;
+    /** The most recent error, if any. */
+    error: Error | null;
+    /** The most recent verification result. */
+    lastResult: VerificationResult | null;
+    /** Number of items in the offline queue. */
+    queueSize: number;
+    /** Manually process the offline queue. */
+    processQueue: () => Promise<void>;
+    /** The underlying client instance. */
+    client: VerifyAIClient;
+    /** The offline queue instance (null if offlineMode is disabled). */
+    offlineQueue: OfflineQueue | null;
+}
+/**
+ * React hook for Verify AI. Provides verification methods,
+ * loading/error state, and optional offline queue management.
+ *
+ * @example
+ * ```tsx
+ * const { verify, loading, lastResult, error } = useVerifyAI({
+ *   apiKey: 'vai_your_api_key',
+ *   offlineMode: true,
+ * });
+ *
+ * const handleCapture = async (base64Image: string) => {
+ *   const result = await verify({
+ *     image: base64Image,
+ *     policy: 'scooter_parking',
+ *   });
+ *   if (result?.is_compliant) {
+ *     // Success
+ *   }
+ * };
+ * ```
+ */
+export declare function useVerifyAI(config: VerifyAIConfig): UseVerifyAIReturn;

package/lib/hooks/useVerifyAI.js

@@ -0,0 +1,97 @@
+import { useMemo, useCallback, useState, useEffect } from 'react';
+import { AppState } from 'react-native';
+import { VerifyAIClient } from '../client';
+import { OfflineQueue } from '../storage/offlineQueue';
+/**
+ * React hook for Verify AI. Provides verification methods,
+ * loading/error state, and optional offline queue management.
+ *
+ * @example
+ * ```tsx
+ * const { verify, loading, lastResult, error } = useVerifyAI({
+ *   apiKey: 'vai_your_api_key',
+ *   offlineMode: true,
+ * });
+ *
+ * const handleCapture = async (base64Image: string) => {
+ *   const result = await verify({
+ *     image: base64Image,
+ *     policy: 'scooter_parking',
+ *   });
+ *   if (result?.is_compliant) {
+ *     // Success
+ *   }
+ * };
+ * ```
+ */
+export function useVerifyAI(config) {
+    const client = useMemo(() => new VerifyAIClient(config), [config.apiKey, config.baseUrl, config.timeout]);
+    const offlineQueue = useMemo(() => (config.offlineMode ? new OfflineQueue(client) : null), [client, config.offlineMode]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [lastResult, setLastResult] = useState(null);
+    const [queueSize, setQueueSize] = useState(0);
+    // Refresh queue size
+    const refreshQueueSize = useCallback(async () => {
+        if (offlineQueue) {
+            const size = await offlineQueue.getQueueSize();
+            setQueueSize(size);
+        }
+    }, [offlineQueue]);
+    // Process queue on app foreground
+    useEffect(() => {
+        if (!offlineQueue)
+            return;
+        refreshQueueSize();
+        const handleAppState = (state) => {
+            if (state === 'active') {
+                offlineQueue.processQueue().then(() => refreshQueueSize());
+            }
+        };
+        const subscription = AppState.addEventListener('change', handleAppState);
+        return () => subscription.remove();
+    }, [offlineQueue, refreshQueueSize]);
+    const verify = useCallback(async (request) => {
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await client.verify(request);
+            setLastResult(result);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            // If offline mode, queue the request
+            if (offlineQueue) {
+                await offlineQueue.enqueue(request);
+                await refreshQueueSize();
+                return null;
+            }
+            throw error;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, offlineQueue, refreshQueueSize]);
+    const listVerifications = useCallback((params) => client.listVerifications(params), [client]);
+    const getVerification = useCallback((id) => client.getVerification(id), [client]);
+    const processQueue = useCallback(async () => {
+        if (!offlineQueue)
+            return;
+        await offlineQueue.processQueue((_, result) => setLastResult(result));
+        await refreshQueueSize();
+    }, [offlineQueue, refreshQueueSize]);
+    return {
+        verify,
+        listVerifications,
+        getVerification,
+        loading,
+        error,
+        lastResult,
+        queueSize,
+        processQueue,
+        client,
+        offlineQueue,
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { VerifyAIClient, VerifyAIRequestError } from './client';
+export { useVerifyAI } from './hooks/useVerifyAI';
+export type { UseVerifyAIReturn } from './hooks/useVerifyAI';
+export { VerifyAIScanner } from './components/VerifyAIScanner';
+export type { VerifyAIScannerProps } from './components/VerifyAIScanner';
+export { OfflineQueue } from './storage/offlineQueue';
+export type { VerifyAIConfig, VerificationRequest, VerificationResult, VerificationListResponse, VerificationListParams, QueueItem, VerifyAIError, ScannerStatus, ScannerOverlayConfig, } from './types';

package/lib/index.js

@@ -0,0 +1,8 @@
+// Client
+export { VerifyAIClient, VerifyAIRequestError } from './client';
+// Hooks
+export { useVerifyAI } from './hooks/useVerifyAI';
+// Components
+export { VerifyAIScanner } from './components/VerifyAIScanner';
+// Offline Queue
+export { OfflineQueue } from './storage/offlineQueue';

package/lib/storage/offlineQueue.d.ts

@@ -0,0 +1,50 @@
+import type { VerificationRequest, VerificationResult, QueueItem } from '../types';
+import { VerifyAIClient } from '../client';
+export declare class OfflineQueue {
+    private client;
+    private processing;
+    private migrated;
+    constructor(client: VerifyAIClient);
+    /**
+     * Migrate from legacy single-key storage to per-item keys.
+     * Runs once per instance, no-ops if already migrated or no legacy data.
+     */
+    private migrateIfNeeded;
+    private getManifest;
+    private setManifest;
+    /**
+     * Add a verification request to the offline queue.
+     * Returns a temporary ID that can be used to track the item.
+     */
+    enqueue(request: VerificationRequest): Promise<string>;
+    /**
+     * Get all items currently in the offline queue.
+     */
+    getQueue(): Promise<QueueItem[]>;
+    /**
+     * Get the number of items waiting in the queue.
+     */
+    getQueueSize(): Promise<number>;
+    /**
+     * Remove an item from the queue by ID.
+     */
+    remove(id: string): Promise<void>;
+    /**
+     * Clear all items from the queue.
+     */
+    clear(): Promise<void>;
+    /**
+     * Process all queued items, sending them to the API.
+     * Returns results for successfully processed items.
+     *
+     * Call this when the device comes back online or on app foreground.
+     *
+     * @param onResult - Optional callback fired for each successful verification
+     * @param maxRetries - Maximum retry attempts before dropping an item (default: 3)
+     */
+    processQueue(onResult?: (queueId: string, result: VerificationResult) => void, maxRetries?: number): Promise<{
+        processed: number;
+        failed: number;
+        remaining: number;
+    }>;
+}