@jupitermetalabs/face-zk-sdk 0.3.4 → 0.3.7

package/dist/react-native/adapters/livenessProvider.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Liveness Provider Adapter for React Native
+ *
+ * Bridges the WebView-based liveness engine (liveness.js + antispoof ONNX model)
+ * to the SDK's LivenessProvider interface consumed by verifyOnly / verifyWithProof.
+ *
+ * ARCHITECTURE
+ * ============
+ * Real-time liveness detection runs entirely inside the ZkFaceAuth WebView component:
+ *   - MediaPipe FaceMesh: depth checks, challenge/response (blink, head turns),
+ *     perspective ratio check
+ *   - ONNX anti-spoof model: EMA-smoothed spoof score over the session
+ *
+ * When the WebView completes it calls onSuccess(imageUri, metadata) where
+ * metadata = { spoofScore: number }.  The functions below convert that into
+ * the LivenessResult / LivenessProvider types expected by the SDK core.
+ *
+ * USAGE PATTERN (inside FaceZkVerificationFlow or your own flow)
+ * ===============================================================
+ *   const handleLivenessSuccess = (imageUri: string, metadata?: { spoofScore: number }) => {
+ *     const result = createLivenessResultFromWebView(metadata?.spoofScore ?? 1.0);
+ *     const provider = createWebViewLivenessProvider(result);
+ *     runVerification(imageUri, provider);
+ *   };
+ */
+import type { LivenessProvider } from "../../core/verification-core";
+import type { LivenessResult } from "../../core/types";
+/**
+ * Build a LivenessResult from the metadata emitted by the ZkFaceAuth WebView.
+ *
+ * @param spoofScore  EMA anti-spoof score from the ONNX model (0 = definitely real, 1 = spoof)
+ * @param threshold   Fail if spoofScore >= threshold (default 0.6, matching liveness.js)
+ */
+export declare function createLivenessResultFromWebView(spoofScore: number, threshold?: number): LivenessResult;
+/**
+ * Wrap a pre-computed LivenessResult into a LivenessProvider.
+ *
+ * Use this after the ZkFaceAuth WebView completes so the SDK's verifyOnly /
+ * verifyWithProof can record the real ONNX scores in VerificationOutcome.liveness.
+ *
+ * The imageUri argument is ignored because the check already ran inside the WebView.
+ */
+export declare function createWebViewLivenessProvider(preComputedResult: LivenessResult): LivenessProvider;
+/**
+ * Configuration for {@link createLivenessProvider}.
+ *
+ * **Default path (WebView):** omit `service` and pass `spoofScore` from the
+ * ZkFaceAuth WebView's `onSuccess` callback. The SDK built-in anti-spoof model
+ * is used and the result is pre-computed before verification runs.
+ *
+ * **Custom path:** provide `service` to plug in any host-owned liveness
+ * implementation (e.g. iOS FaceID, a cloud API, your own ONNX model).
+ */
+export interface LivenessProviderConfig {
+    /** EMA spoof score from the ONNX model (0 = real, 1 = spoof). Default: 0. */
+    spoofScore?: number;
+    /** Threshold above which the frame is considered a spoof. Default: 0.6. */
+    threshold?: number;
+    /**
+     * Your own liveness service. When provided, `spoofScore` and `threshold`
+     * are ignored and the service's `checkLiveness` result is used instead.
+     */
+    service?: {
+        checkLiveness(imageUri: string): Promise<{
+            passed: boolean;
+            score?: number;
+            checks?: Array<{
+                id: string;
+                passed: boolean;
+                score?: number;
+                reason?: string;
+            }>;
+        }>;
+    };
+    /** Fail if `score < minScore` (only applied when using `service`). */
+    minScore?: number;
+    /** Require all listed check IDs to pass (only applied when using `service`). */
+    requiredChecks?: string[];
+}
+/**
+ * Unified liveness provider factory.
+ *
+ * - **No `service`** (default): wraps the ZkFaceAuth WebView's pre-computed
+ *   anti-spoof result. Pass `spoofScore` from the WebView's `onSuccess` callback.
+ * - **With `service`**: delegates every `checkLiveness` call to your own
+ *   implementation, applying optional `minScore` and `requiredChecks` guards.
+ *
+ * @example Default (SDK built-in WebView)
+ * ```ts
+ * const provider = createLivenessProvider({ spoofScore: metadata.spoofScore });
+ * ```
+ *
+ * @example Custom host service
+ * ```ts
+ * const provider = createLivenessProvider({ service: myLivenessService, minScore: 0.8 });
+ * ```
+ */
+export declare function createLivenessProvider(config?: LivenessProviderConfig): LivenessProvider;
+/**
+ * Interface for a ZkFaceAuth-based liveness analysis service.
+ * Used with {@link createZkFaceAuthLivenessProvider} for post-capture re-verification.
+ */
+export interface ZkFaceAuthLivenessService {
+    analyzeLiveness(imageUri: string): Promise<{
+        passed: boolean;
+        score: number;
+        checks: Array<{
+            type: "blink" | "motion" | "pose_variation" | "spoof_texture" | "depth_or_3d";
+            passed: boolean;
+            confidence: number;
+        }>;
+    }>;
+}
+/**
+ * Create a liveness provider that wraps a ZkFaceAuth-based `analyzeLiveness` service.
+ * Useful for post-capture liveness re-verification on an already-captured image.
+ */
+export declare function createZkFaceAuthLivenessProvider(zkFaceAuthService: ZkFaceAuthLivenessService): LivenessProvider;

package/dist/react-native/adapters/livenessProvider.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLivenessResultFromWebView = createLivenessResultFromWebView;
+exports.createWebViewLivenessProvider = createWebViewLivenessProvider;
+exports.createLivenessProvider = createLivenessProvider;
+exports.createZkFaceAuthLivenessProvider = createZkFaceAuthLivenessProvider;
+// Default threshold must match SPOOF_EMA_FAIL_THRESHOLD in liveness.js (0.60).
+// The WebView expresses "spoof confidence" (lower = more real), whereas the SDK
+// expresses "liveness score" (higher = more real), so we invert: realScore = 1 - spoofScore.
+const DEFAULT_ANTISPOOF_THRESHOLD = 0.6;
+/**
+ * Build a LivenessResult from the metadata emitted by the ZkFaceAuth WebView.
+ *
+ * @param spoofScore  EMA anti-spoof score from the ONNX model (0 = definitely real, 1 = spoof)
+ * @param threshold   Fail if spoofScore >= threshold (default 0.6, matching liveness.js)
+ */
+function createLivenessResultFromWebView(spoofScore, threshold = DEFAULT_ANTISPOOF_THRESHOLD) {
+    const realScore = 1 - spoofScore; // invert: SDK convention is higher = more real
+    const passed = spoofScore < threshold;
+    const checks = [
+        {
+            id: "spoof_texture",
+            passed,
+            score: realScore,
+            reason: passed
+                ? `Anti-spoof check passed (score: ${realScore.toFixed(3)})`
+                : `Anti-spoof check failed (spoof score: ${spoofScore.toFixed(3)} ≥ threshold ${threshold})`,
+        },
+    ];
+    // The WebView only surfaces the final EMA score; individual challenge checks
+    // (blink, head-turn, perspective) are gated inside liveness.js — if the image
+    // reached onSuccess() those challenges already passed.
+    checks.push({
+        id: "motion",
+        passed: true,
+        reason: "Liveness challenges completed (blink / head-turn / perspective)",
+    });
+    return {
+        passed,
+        score: realScore,
+        checks,
+    };
+}
+/**
+ * Wrap a pre-computed LivenessResult into a LivenessProvider.
+ *
+ * Use this after the ZkFaceAuth WebView completes so the SDK's verifyOnly /
+ * verifyWithProof can record the real ONNX scores in VerificationOutcome.liveness.
+ *
+ * The imageUri argument is ignored because the check already ran inside the WebView.
+ */
+function createWebViewLivenessProvider(preComputedResult) {
+    return {
+        async checkLiveness(_imageUri) {
+            return preComputedResult;
+        },
+    };
+}
+/**
+ * Unified liveness provider factory.
+ *
+ * - **No `service`** (default): wraps the ZkFaceAuth WebView's pre-computed
+ *   anti-spoof result. Pass `spoofScore` from the WebView's `onSuccess` callback.
+ * - **With `service`**: delegates every `checkLiveness` call to your own
+ *   implementation, applying optional `minScore` and `requiredChecks` guards.
+ *
+ * @example Default (SDK built-in WebView)
+ * ```ts
+ * const provider = createLivenessProvider({ spoofScore: metadata.spoofScore });
+ * ```
+ *
+ * @example Custom host service
+ * ```ts
+ * const provider = createLivenessProvider({ service: myLivenessService, minScore: 0.8 });
+ * ```
+ */
+function createLivenessProvider(config = {}) {
+    if (config.service) {
+        const { service, minScore, requiredChecks } = config;
+        return {
+            async checkLiveness(imageUri) {
+                const result = await service.checkLiveness(imageUri);
+                let passed = result.passed;
+                if (minScore !== undefined && result.score !== undefined && result.score < minScore) {
+                    passed = false;
+                }
+                if (requiredChecks?.length && result.checks) {
+                    for (const checkId of requiredChecks) {
+                        if (!result.checks.find((c) => c.id === checkId)?.passed) {
+                            passed = false;
+                            break;
+                        }
+                    }
+                }
+                return {
+                    passed,
+                    score: result.score,
+                    checks: result.checks?.map((c) => ({
+                        id: c.id,
+                        passed: c.passed,
+                        score: c.score,
+                        reason: c.reason,
+                    })),
+                };
+            },
+        };
+    }
+    // Default: pre-computed WebView result
+    const result = createLivenessResultFromWebView(config.spoofScore ?? 0, config.threshold);
+    return {
+        async checkLiveness(_imageUri) {
+            return result;
+        },
+    };
+}
+/**
+ * Create a liveness provider that wraps a ZkFaceAuth-based `analyzeLiveness` service.
+ * Useful for post-capture liveness re-verification on an already-captured image.
+ */
+function createZkFaceAuthLivenessProvider(zkFaceAuthService) {
+    return {
+        async checkLiveness(imageUri) {
+            const result = await zkFaceAuthService.analyzeLiveness(imageUri);
+            return {
+                passed: result.passed,
+                score: result.score,
+                checks: result.checks.map((check) => ({
+                    id: check.type,
+                    passed: check.passed,
+                    score: check.confidence,
+                })),
+            };
+        },
+    };
+}

package/dist/react-native/adapters/zkProofEngine-webview.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * ZK Proof Engine Adapter for React Native WebView
+ *
+ * Wraps the ZkProofBridge to implement the ZkProofEngine interface.
+ * This adapter bridges the SDK core logic to the Plonky3 WebView implementation.
+ */
+import type { ZkProofEngine } from "../../core/types";
+import type { ZkProofBridge } from "../components/ZkProofWebView";
+/**
+ * Create a ZK proof engine that wraps the WebView-based ZkProofBridge.
+ *
+ * This adapter:
+ * - Implements the ZkProofEngine interface
+ * - Delegates to ZkProofBridge for proof generation/verification
+ * - Handles initialization and ready state checking
+ *
+ * Note: The bridge must be initialized (loadWasmModule called) before use.
+ * The caller is responsible for ensuring the bridge is ready.
+ *
+ * @param bridge ZkProofBridge instance from ZkProofWebView component
+ * @param verificationKey Optional VK string (defaults to empty string for now)
+ * @returns ZkProofEngine implementation
+ */
+export declare function createZkProofEngineWebView(bridge: ZkProofBridge, verificationKey?: string): ZkProofEngine;
+/**
+ * Helper function to initialize the ZK proof engine.
+ *
+ * This handles the full initialization flow:
+ * 1. Wait for bridge to be ready
+ * 2. Load WASM module
+ * 3. Create and return the engine
+ *
+ * Usage:
+ * ```ts
+ * const bridge = new ZkProofBridge(webViewRef);
+ * const engine = await initializeZkProofEngine(bridge);
+ * ```
+ *
+ * @param bridge ZkProofBridge instance
+ * @param verificationKey Optional VK string
+ * @returns Promise<ZkProofEngine> Ready-to-use engine
+ * @throws Error if initialization fails
+ */
+export declare function initializeZkProofEngine(bridge: ZkProofBridge, verificationKey?: string): Promise<ZkProofEngine>;
+/**
+ * Check if a ZK proof bridge is ready for use.
+ *
+ * @param bridge ZkProofBridge instance
+ * @returns true if bridge is ready, false otherwise
+ */
+export declare function isZkProofBridgeReady(bridge: ZkProofBridge): boolean;
+/**
+ * Get a human-readable status message for the ZK proof bridge.
+ *
+ * @param bridge ZkProofBridge instance
+ * @returns Status message string
+ */
+export declare function getZkProofBridgeStatusMessage(bridge: ZkProofBridge): string;

package/dist/react-native/adapters/zkProofEngine-webview.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createZkProofEngineWebView = createZkProofEngineWebView;
+exports.initializeZkProofEngine = initializeZkProofEngine;
+exports.isZkProofBridgeReady = isZkProofBridgeReady;
+exports.getZkProofBridgeStatusMessage = getZkProofBridgeStatusMessage;
+/**
+ * Create a ZK proof engine that wraps the WebView-based ZkProofBridge.
+ *
+ * This adapter:
+ * - Implements the ZkProofEngine interface
+ * - Delegates to ZkProofBridge for proof generation/verification
+ * - Handles initialization and ready state checking
+ *
+ * Note: The bridge must be initialized (loadWasmModule called) before use.
+ * The caller is responsible for ensuring the bridge is ready.
+ *
+ * @param bridge ZkProofBridge instance from ZkProofWebView component
+ * @param verificationKey Optional VK string (defaults to empty string for now)
+ * @returns ZkProofEngine implementation
+ */
+function createZkProofEngineWebView(bridge, verificationKey = "") {
+    return {
+        async generateProof(referenceEmbedding, liveEmbedding, nonce) {
+            // Check if bridge is ready
+            if (bridge.status !== "ready") {
+                throw new Error(`ZkProofBridge not ready. Current status: ${bridge.status}`);
+            }
+            // Delegate to bridge
+            // Note: ZkProofBridge uses different parameter names (embedding1, embedding2)
+            // but the same underlying data
+            const result = await bridge.generateProof(referenceEmbedding, liveEmbedding, nonce);
+            return {
+                proof: result.proof,
+                publicInputs: result.publicInputs,
+            };
+        },
+        async verifyProof(proof, publicInputs) {
+            // Check if bridge is ready
+            if (bridge.status !== "ready") {
+                throw new Error(`ZkProofBridge not ready. Current status: ${bridge.status}`);
+            }
+            // Delegate to bridge
+            // Note: verificationKey is required by the bridge but may be empty for now
+            const verified = await bridge.verifyProof(proof, publicInputs, verificationKey);
+            return verified;
+        },
+        async getProofHash(proof) {
+            // Check if bridge is ready
+            if (bridge.status !== "ready") {
+                throw new Error(`ZkProofBridge not ready. Current status: ${bridge.status}`);
+            }
+            // Delegate to bridge
+            const hash = await bridge.getProofHash(proof);
+            return hash;
+        },
+    };
+}
+/**
+ * Helper function to initialize the ZK proof engine.
+ *
+ * This handles the full initialization flow:
+ * 1. Wait for bridge to be ready
+ * 2. Load WASM module
+ * 3. Create and return the engine
+ *
+ * Usage:
+ * ```ts
+ * const bridge = new ZkProofBridge(webViewRef);
+ * const engine = await initializeZkProofEngine(bridge);
+ * ```
+ *
+ * @param bridge ZkProofBridge instance
+ * @param verificationKey Optional VK string
+ * @returns Promise<ZkProofEngine> Ready-to-use engine
+ * @throws Error if initialization fails
+ */
+async function initializeZkProofEngine(bridge, verificationKey = "") {
+    // Load WASM module if not already loaded
+    if (bridge.status === "idle" || bridge.status === "error") {
+        console.log("[ZkProofEngine] Initializing WASM module...");
+        await bridge.loadWasmModule();
+        console.log("[ZkProofEngine] WASM module initialized successfully");
+    }
+    // Check final status
+    if (bridge.status !== "ready") {
+        throw new Error(`Failed to initialize ZK proof engine. Bridge status: ${bridge.status}`);
+    }
+    // Create and return engine
+    return createZkProofEngineWebView(bridge, verificationKey);
+}
+/**
+ * Check if a ZK proof bridge is ready for use.
+ *
+ * @param bridge ZkProofBridge instance
+ * @returns true if bridge is ready, false otherwise
+ */
+function isZkProofBridgeReady(bridge) {
+    return bridge.status === "ready";
+}
+/**
+ * Get a human-readable status message for the ZK proof bridge.
+ *
+ * @param bridge ZkProofBridge instance
+ * @returns Status message string
+ */
+function getZkProofBridgeStatusMessage(bridge) {
+    switch (bridge.status) {
+        case "idle":
+            return "ZK proof engine not initialized";
+        case "loading":
+            return "Loading ZK proof WASM module...";
+        case "ready":
+            return "ZK proof engine ready";
+        case "error":
+            return "ZK proof engine failed to initialize";
+        default:
+            return "Unknown status";
+    }
+}

package/dist/react-native/bundledRuntimeAssets.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Bundled Runtime Asset Defaults
+ *
+ * This is the ONLY file in the SDK that contains `require()` calls for runtime
+ * WebView assets (HTML pages, JS bundles, WASM binaries, data blobs).
+ *
+ * All SDK components and hooks must import from here rather than calling
+ * `require('../../assets/...')` directly. This keeps Metro asset resolution
+ * centralised and makes every asset overridable via `FaceZkConfig.runtimeAssets`.
+ *
+ * NOTE ON ONNX MODELS: model files (antispoof.onnx, det_500m.onnx, etc.) are NOT
+ * included here. They are not shipped in the npm package and must always be provided
+ * via `FaceZkConfig.models.*`. Missing model config produces a clear error at runtime.
+ */
+import type { FaceZkRuntimeAssetsConfig } from '../config/types';
+/**
+ * Bundled defaults for all `FaceZkRuntimeAssetsConfig` fields.
+ * Each entry wraps a Metro `require()` so the asset is resolved at bundle time
+ * from the SDK's own `assets/` directory.
+ *
+ * Components should call `resolveRuntimeAsset()` rather than accessing this
+ * object directly — that utility handles the config-override + fallback logic.
+ */
+export declare const BUNDLED_RUNTIME_ASSETS: Required<FaceZkRuntimeAssetsConfig>;

package/dist/react-native/bundledRuntimeAssets.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUNDLED_RUNTIME_ASSETS = void 0;
+/**
+ * Bundled defaults for all `FaceZkRuntimeAssetsConfig` fields.
+ * Each entry wraps a Metro `require()` so the asset is resolved at bundle time
+ * from the SDK's own `assets/` directory.
+ *
+ * Components should call `resolveRuntimeAsset()` rather than accessing this
+ * object directly — that utility handles the config-override + fallback logic.
+ */
+exports.BUNDLED_RUNTIME_ASSETS = {
+    // ORT Runtime
+    ortJs: { module: require('../assets/onnx/ort.min.js.txt') },
+    ortWasm: { module: require('../assets/onnx/ort-wasm-simd.wasm') },
+    // Liveness WebView
+    livenessHtml: { module: require('../assets/liveness/index.html') },
+    antispoofJs: { module: require('../assets/liveness/antispoof.js.txt') },
+    livenessJs: { module: require('../assets/liveness/liveness.js.txt') },
+    // MediaPipe
+    mediapipeFaceMeshJs: { module: require('../assets/mediapipe/face_mesh.js.txt') },
+    mediapipeSimdWasm: { module: require('../assets/mediapipe/face_mesh_solution_simd_wasm_bin.wasm') },
+    mediapipeWasm: { module: require('../assets/mediapipe/face_mesh_solution_wasm_bin.wasm') },
+    mediapipeData: { module: require('../assets/mediapipe/face_mesh_solution_packed_assets.data') },
+    // Face Guidance WebView
+    faceGuidanceHtml: { module: require('../assets/face-guidance/index.html') },
+    faceGuidancePoseJs: { module: require('../assets/face-guidance/pose-guidance.js.txt') },
+    faceGuidanceLogicJs: { module: require('../assets/face-guidance/face-logic.js.txt') },
+};

package/dist/react-native/components/FacePoseGuidanceWebView.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2026 JupiterMeta Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import React from "react";
+interface FacePoseGuidanceWebViewProps {
+    referenceImageUri?: string;
+    headless?: boolean;
+    onSuccess: (imageUri: string, metadata?: any) => void;
+    onError: (message: string) => void;
+    onCancel?: () => void;
+    manualTargetPose?: {
+        yaw: number;
+        pitch: number;
+        roll: number;
+    };
+}
+export declare const FacePoseGuidanceWebView: React.FC<FacePoseGuidanceWebViewProps>;
+export {};