react-native-image-stitcher 0.1.0

package/cpp/stitcher.hpp

@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// stitcher.hpp — shared cv::Stitcher orchestration used by both
+// iOS (via Obj-C++ bridge in OpenCVStitcherBridge.mm) and Android
+// (via JNI in image_stitcher_jni.cpp).
+//
+// Why this exists
+// ───────────────
+//
+// Before 2026-05-15, iOS had a hand-rolled cv::detail::* pipeline
+// (~3,000 lines in OpenCVStitcher.mm) while Android used the
+// high-level cv::Stitcher::create() API (~600 lines in
+// image_stitcher_jni.cpp).  Two implementations of the same algorithm
+// drifted independently — fixes landed on one platform and didn't on
+// the other.  This file collapses that into a single source of truth.
+//
+// V1 scope (this commit): port the Android high-level pipeline
+// verbatim into shared C++ + add the C+D progressive-confidence retry
+// loop + dimension/memory instrumentation.  Both platforms call this.
+//
+// V2 scope (follow-up): port iOS's manual cv::detail::* pipeline
+// features (explicit leaveBiggestComponent retry around
+// just the prune step rather than the whole stitch — 5-10× cheaper;
+// wave correction; exposure compensator) into this file as a
+// SECOND code path selectable via StitchConfig::useManualPipeline.
+// Until then, iOS gets the Android-level capability set.
+//
+// API design
+// ──────────
+//
+// One function: stitchFramePaths(framePaths, outputPath, config).
+//
+// All inputs marshalled as primitive C++ types.  Output is a
+// StitchResult struct that carries success/error info + the C+D
+// drop-count telemetry.  Loggin happens via an optional callback so
+// the iOS bridge can plumb to os_log and the Android bridge to
+// __android_log_print — same source, different sink.
+//
+// Threading: not thread-safe.  Caller must serialise.  Each
+// invocation is independent (no shared mutable state).
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+
+namespace retailens {
+
+// Stable error codes.  Mirror the JS-side `StitchErrorCode` enum so
+// the bridge layers can map these to NSError.code / Java throwable
+// without translation tables.
+//
+// Bit-for-bit aligned to cv::Stitcher::Status values where possible
+// (NeedMoreImages, HomographyEstimationFailed, CameraParamsAdjustFailed)
+// + a few new codes for failure modes that cv::Stitcher itself
+// doesn't surface (image read/write failure, all-frames-dropped).
+//
+// Manual-pipeline-specific failure modes (added 2026-05-15 as part of
+// the V2 shared-port code-review pass; previously these all collapsed
+// into UnknownCvException, which made post-mortem triage from JS-side
+// telemetry impossible):
+//   PreStitchMemoryAbort        — manual pipeline detected RSS above
+//                                 the per-device pre-stitch threshold
+//                                 and bailed before allocating compose
+//                                 buffers.  Operator should retry on
+//                                 fresh app launch or lower compose MP.
+//   ComposeResizeFailed         — cv::resize threw inside the compose-
+//                                 stage downscale loop (Step 7c).  Most
+//                                 commonly a recycled-mmap allocator
+//                                 issue when stitching consecutively;
+//                                 a fresh process usually recovers.
+//   WarpFailed                  — warper->warp threw inside the warp
+//                                 loop (Step 8b).  Camera params from
+//                                 BA may be degenerate; check
+//                                 framesIncluded vs framesRequested.
+//   EmptyPanorama               — blender->blend completed but produced
+//                                 a 0×0 panorama.  Should never happen
+//                                 in practice; if it does, the failure
+//                                 is upstream in the warp/feed loop.
+enum class StitchErrorCode : int32_t {
+    Ok                          = 0,
+    NeedMoreImages              = 1,  // cv::Stitcher::ERR_NEED_MORE_IMGS
+    HomographyEstimationFailed  = 2,  // cv::Stitcher::ERR_HOMOGRAPHY_EST_FAIL
+    CameraParamsAdjustFailed    = 3,  // cv::Stitcher::ERR_CAMERA_PARAMS_ADJUST_FAIL
+    ImageReadFailed             = 100,
+    ImageWriteFailed            = 101,
+    AllFramesDroppedByConfidence = 102,
+    PreStitchMemoryAbort        = 103,
+    ComposeResizeFailed         = 104,
+    WarpFailed                  = 105,
+    EmptyPanorama               = 106,
+    InvalidArgument             = 200,
+    UnknownCvException          = 300,
+};
+
+
+// Stitcher mode selector — maps to cv::Stitcher::Mode.
+//
+//   Panorama: rotation-only (spherical/cylindrical/plane warper +
+//             BundleAdjusterRay + BestOf2NearestMatcher).  Best for
+//             rotate-in-place captures.
+//   Scans:    affine (plane warper + BundleAdjusterAffine +
+//             AffineBestOf2NearestMatcher).  Best for shelf-pan
+//             translation captures.
+//
+// Caller (typically the JS engineMode resolver) picks per capture.
+// "auto" resolution happens UPSTREAM in JS via accumulated
+// translation vs rotation totals from the KeyframeGate — by the
+// time we get here, it's a concrete mode.
+enum class StitchMode : int32_t {
+    Panorama = 0,
+    Scans    = 1,
+};
+
+
+// Configuration bundle for a single stitch invocation.  All fields
+// have safe defaults so callers only override what they care about.
+//
+// Resolution budgets (`*ResolMP`) are in megapixels per frame:
+//   < 0.0  → entry-point picks its own appropriate default
+//   ≥ 0.0  → cap at this MP target via cv::Stitcher::set*Resol()
+//
+// compositingResolMP intentionally defaults to a NEGATIVE SENTINEL so
+// the two entry points can pick different appropriate defaults:
+//
+//   * High-level stitchFramePaths() (cv::Stitcher::create wrapper):
+//     falls back to 1.0 MP.  cv::Stitcher's library default for
+//     compositing is ORIG_RESOL (-1.0) which composes at full sensor
+//     resolution and trivially OOMs on Android — 1.0 MP caps that
+//     while preserving most of the sharpness.
+//
+//   * Manual stitchFramePathsManual() (cv::detail::* pipeline):
+//     falls back to 0.6 MP.  The hand-rolled pipeline blends at
+//     compose-MP DIRECTLY (rather than re-warping from features-
+//     resolution work frames as cv::Stitcher does internally), which
+//     means memory peak scales more aggressively with compose-MP.
+//     1.0 MP pushed iOS into jetsam territory; 0.6 MP is the "safe
+//     sharp" sweet spot documented in OpenCVStitcher.mm comments.
+struct StitchConfig {
+    std::string warperType           = "plane";        // "plane"|"cylindrical"|"spherical"
+    std::string blenderType          = "multiband";    // "multiband"|"feather"
+    std::string seamFinderType       = "graphcut";     // "graphcut"|"skip"|"voronoi"
+    StitchMode  stitchMode           = StitchMode::Panorama;
+    std::string captureOrientation   = "portrait";     // "portrait"|"portrait-upside-down"|"landscape-left"|"landscape-right"
+    bool        useInscribedRectCrop = false;          // bbox-only crop is the default
+    double      registrationResolMP  = -1.0;           // < 0 = cv default (0.6 MP)
+    double      seamEstimationResolMP = -1.0;          // < 0 = cv default (0.1 MP)
+    double      compositingResolMP   = -1.0;           // < 0 = entry-specific default (high-level: 1.0 MP, manual: 0.6 MP)
+    int         jpegQuality          = 85;
+
+    // Total device RAM in megabytes.  Used by the manual pipeline's
+    // pre-stitch memory abort heuristic to decide whether to short-
+    // circuit a stitch that would likely OOM.  When < 0 (default),
+    // falls back to a conservative assumption (4 GB = kAssumedTotalRAMGB
+    // in stitcher.cpp).  Callers should plumb:
+    //   iOS:     NSProcessInfo.processInfo.physicalMemory / (1024*1024)
+    //   Android: ActivityManager.getMemoryInfo().totalMem / (1024*1024)
+    //            or sysconf(_SC_PHYS_PAGES) * sysconf(_SC_PAGE_SIZE) / (1024*1024)
+    double availableRamMB = -1.0;
+
+    // Manual-pipeline opt-in (V2 of the shared port).
+    //
+    // Set true to route stitchFramePaths() through the hand-rolled
+    // cv::detail::* pipeline implemented in stitchFramePathsManual()
+    // instead of the high-level cv::Stitcher::create() wrapper.  The
+    // manual pipeline gives finer control that the high-level API
+    // hides behind defaults that don't fit our shelf-pan capture
+    // shape:
+    //
+    //   * Seam finder runs at a SEPARATE seam-MP budget (~0.1 MP
+    //     default) and the seam mask is upscaled back to compose-MP
+    //     before feeding the blender.  GraphCut is roughly O(N²) in
+    //     pixels — running it at compose-MP (1.0 MP) costs ~100× more
+    //     than at seam-MP and was timing out finalize() in JS.
+    //
+    //   * MultiBandBlender's Laplacian pyramid is built at compose-MP
+    //     directly (rather than re-warping from features-resolution
+    //     work frames).  Cylindrical-era sharpness restored on iOS.
+    //
+    //   * leaveBiggestComponent runs at PRUNE granularity (i.e., the
+    //     retry happens BEFORE the expensive BA / warp / blend), not
+    //     around the whole pipeline.  Retry cost is 5-10× cheaper than
+    //     the high-level cv::Stitcher's C+D loop that re-runs every
+    //     stage at each threshold.
+    //
+    //   * Explicit BundleAdjusterRay + wave correction + median focal
+    //     length scale determination — all features cv::Stitcher does
+    //     internally but with parameters we can't override (iter cap,
+    //     wave-correct kind, confidence threshold).
+    //
+    // Android currently leaves this false (the high-level pipeline
+    // works fine on Android's pre-V16 keyframe budgets).  iOS will
+    // flip it to true once the manual port is verified — separate
+    // commit from this V2 introduction.
+    bool        useManualPipeline    = false;
+};
+
+
+// Result returned to the caller.  On success: outputPath written +
+// dimensions + C+D telemetry.  On failure: errorCode + errorMessage
+// (errorCode is the primary signal; message is human-readable).
+struct StitchResult {
+    bool             success         = false;
+    StitchErrorCode  errorCode       = StitchErrorCode::UnknownCvException;
+    std::string      errorMessage;
+
+    int32_t  width                   = 0;
+    int32_t  height                  = 0;
+
+    // C+D telemetry — filled in even on success.  See
+    // 2026-05-15 commit 57ecccd for context.
+    int32_t  framesRequested         = 0;
+    int32_t  framesIncluded          = 0;
+    double   finalConfidenceThresh   = -1.0;  // The threshold value that succeeded; -1 if not relevant.
+
+    int64_t  durationMs              = 0;
+};
+
+
+// Logging callback type — bridge layers plug their platform logger
+// (os_log on iOS, __android_log_print on Android).  Use nullptr to
+// silence.
+//
+//   level: 0=info, 1=warn, 2=error
+//   tag:   short tag like "[stitch]" or "[dimstat]"
+//   msg:   the formatted message (caller must format before passing)
+using LogFn = std::function<void(int level, const char* tag, const char* msg)>;
+
+
+// Primary entry point.  Loads input JPEGs, configures cv::Stitcher
+// per the config, runs the C+D progressive-confidence retry loop,
+// crops, bake-rotates, writes the output JPEG.
+//
+// When `config.useManualPipeline` is true the call is routed to
+// `stitchFramePathsManual()` instead — see below for the manual
+// pipeline's structural differences.
+//
+// Thread-safe per-call (no shared state); caller must serialise
+// concurrent calls.
+//
+// On failure (StitchResult::success == false) the output file is
+// not written.  errorCode + errorMessage tell why.
+StitchResult stitchFramePaths(
+    const std::vector<std::string>& framePaths,
+    const std::string&              outputPath,
+    const StitchConfig&             config,
+    LogFn                           logFn = nullptr);
+
+
+// Manual cv::detail::* pipeline entry point.  Same input/output
+// contract as stitchFramePaths(), but uses the hand-rolled stitching
+// pipeline ported from OpenCVStitcher.mm (ORB → BestOf2NearestMatcher
+// → HomographyBasedEstimator → BundleAdjusterRay → wave correct →
+// median-focal warper scale → two-stage resolution (registration_MP
+// / compose_MP) → GraphCutSeamFinder at seam_MP → MultiBandBlender).
+//
+// Use via config.useManualPipeline = true to get this entry point
+// indirectly from stitchFramePaths().  Also callable directly if a
+// future caller wants to bypass the high-level wrapper entirely.
+//
+// Thread-safe per-call (no shared state); caller must serialise
+// concurrent calls.
+//
+// On failure (StitchResult::success == false) the output file is
+// not written.  errorCode + errorMessage tell why.
+StitchResult stitchFramePathsManual(
+    const std::vector<std::string>& framePaths,
+    const std::string&              outputPath,
+    const StitchConfig&             config,
+    LogFn                           logFn = nullptr);
+
+}  // namespace retailens

package/dist/ar/useARSession.d.ts

@@ -0,0 +1,102 @@
+/**
+ * useARSession — React hook for the SDK's ARKit (iOS) / ARCore
+ * (Android) session foundation.
+ *
+ * Phase 4 of the AR measurement plan
+ * (docs/site-content/design/2026-04-29-ar-measurement-and-detection.md).
+ *
+ * What this gives the host:
+ *   - `isAvailable`: whether the device can run AR at all
+ *   - `trackingState`: current AR tracking quality (mirrors Apple's
+ *     enum values exactly — same numeric ids on both platforms)
+ *   - `start()` / `stop()`: lifecycle controls
+ *   - `getFramePoses()`: snapshot the per-frame pose log captured
+ *     during the most recent session, used by Phase 5 stitching
+ *     and Phase 6 measurement
+ *
+ * What this does NOT give:
+ *   The hook is camera-agnostic.  It just runs the AR tracking
+ *   session.  Frame display + capture happen via the SDK's
+ *   AR-backed `<CameraView>` (Phase 4.4 — coming) or the existing
+ *   vision-camera-backed view if AR is unavailable.
+ */
+/**
+ * AR tracking state.  Numeric values mirror iOS' enum and the
+ * Android constants in `RNSARSession.companion`.  Cross-
+ * platform identical; no branching needed in JS.
+ */
+export declare enum ARTrackingState {
+    /** AR not running, not supported, or session was stopped. */
+    NotAvailable = 0,
+    /** Session running but tracking quality not yet usable. */
+    Initialising = 1,
+    /** Session running with usable tracking — poses are good. */
+    Tracking = 2,
+    /** Tracking quality dropped mid-session.  Poses degraded. */
+    Limited = 3
+}
+/**
+ * One captured frame's pose.  Coordinates are in the AR session's
+ * world frame (right-handed, Y-up on iOS / Y-up on Android), with
+ * translation in metres.  Rotation is a unit quaternion; w is the
+ * real component.
+ */
+export interface FramePose {
+    tx: number;
+    ty: number;
+    tz: number;
+    qx: number;
+    qy: number;
+    qz: number;
+    qw: number;
+    /** Camera intrinsics (focal length + principal point) in pixels. */
+    fx: number;
+    fy: number;
+    cx: number;
+    cy: number;
+    imageWidth: number;
+    imageHeight: number;
+    /** Frame timestamp in ms relative to AR session start. */
+    timestampMs: number;
+    trackingState: ARTrackingState;
+}
+export interface UseARSessionReturn {
+    /**
+     * Whether the device can run AR.  Set after the first `start()`
+     * call (or by the explicit `checkAvailability()`).  False on
+     * older iPhones, simulators, and unsupported Android devices.
+     */
+    isAvailable: boolean;
+    /**
+     * Whether the session is currently running.  True between
+     * `start()` and `stop()`.
+     */
+    isRunning: boolean;
+    /** Current tracking quality.  Polled every 500ms while running. */
+    trackingState: ARTrackingState;
+    /**
+     * Start the AR session.  On Android, may trigger a Play Services
+     * for AR install dialog the first time it runs.  Throws if the
+     * device doesn't support AR.
+     */
+    start: () => Promise<void>;
+    /**
+     * Stop the AR session and clear the pose log.  Idempotent;
+     * calling on a stopped session is a no-op.
+     */
+    stop: () => Promise<void>;
+    /**
+     * Snapshot the per-frame pose log captured since the last
+     * `start()`.  Used by the stitcher and measurement APIs after
+     * recording stops.
+     */
+    getFramePoses: () => Promise<FramePose[]>;
+    /**
+     * Drop everything in the pose log.  Call before each new
+     * panorama capture so the log doesn't carry stale poses from
+     * an earlier session.
+     */
+    clearPoseLog: () => Promise<void>;
+}
+export declare function useARSession(): UseARSessionReturn;
+//# sourceMappingURL=useARSession.d.ts.map

package/dist/ar/useARSession.js

@@ -0,0 +1,133 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * useARSession — React hook for the SDK's ARKit (iOS) / ARCore
+ * (Android) session foundation.
+ *
+ * Phase 4 of the AR measurement plan
+ * (docs/site-content/design/2026-04-29-ar-measurement-and-detection.md).
+ *
+ * What this gives the host:
+ *   - `isAvailable`: whether the device can run AR at all
+ *   - `trackingState`: current AR tracking quality (mirrors Apple's
+ *     enum values exactly — same numeric ids on both platforms)
+ *   - `start()` / `stop()`: lifecycle controls
+ *   - `getFramePoses()`: snapshot the per-frame pose log captured
+ *     during the most recent session, used by Phase 5 stitching
+ *     and Phase 6 measurement
+ *
+ * What this does NOT give:
+ *   The hook is camera-agnostic.  It just runs the AR tracking
+ *   session.  Frame display + capture happen via the SDK's
+ *   AR-backed `<CameraView>` (Phase 4.4 — coming) or the existing
+ *   vision-camera-backed view if AR is unavailable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARTrackingState = void 0;
+exports.useARSession = useARSession;
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+/**
+ * AR tracking state.  Numeric values mirror iOS' enum and the
+ * Android constants in `RNSARSession.companion`.  Cross-
+ * platform identical; no branching needed in JS.
+ */
+var ARTrackingState;
+(function (ARTrackingState) {
+    /** AR not running, not supported, or session was stopped. */
+    ARTrackingState[ARTrackingState["NotAvailable"] = 0] = "NotAvailable";
+    /** Session running but tracking quality not yet usable. */
+    ARTrackingState[ARTrackingState["Initialising"] = 1] = "Initialising";
+    /** Session running with usable tracking — poses are good. */
+    ARTrackingState[ARTrackingState["Tracking"] = 2] = "Tracking";
+    /** Tracking quality dropped mid-session.  Poses degraded. */
+    ARTrackingState[ARTrackingState["Limited"] = 3] = "Limited";
+})(ARTrackingState || (exports.ARTrackingState = ARTrackingState = {}));
+function getNativeModule() {
+    const m = react_native_1.NativeModules['RNSARSession'];
+    if (!m || typeof m !== 'object')
+        return null;
+    return m;
+}
+/**
+ * Polling interval for tracking-state updates.  500ms is enough to
+ * feel responsive in the UI without flooding the bridge.
+ */
+const STATE_POLL_INTERVAL_MS = 500;
+function useARSession() {
+    const [isAvailable, setIsAvailable] = (0, react_1.useState)(false);
+    const [isRunning, setIsRunning] = (0, react_1.useState)(false);
+    const [trackingState, setTrackingState] = (0, react_1.useState)(ARTrackingState.NotAvailable);
+    const pollRef = (0, react_1.useRef)(null);
+    const native = getNativeModule();
+    // Probe availability once on mount.  Running on a device without
+    // AR support shouldn't crash anything — `isAvailable` stays
+    // false and the rest of the SDK falls back to vision-camera.
+    (0, react_1.useEffect)(() => {
+        if (!native)
+            return;
+        native.isSupported().then(setIsAvailable).catch((err) => {
+            // eslint-disable-next-line no-console
+            console.warn('[useARSession] isSupported failed', err);
+        });
+    }, [native]);
+    const stopPolling = (0, react_1.useCallback)(() => {
+        if (pollRef.current !== null) {
+            clearInterval(pollRef.current);
+            pollRef.current = null;
+        }
+    }, []);
+    const startPolling = (0, react_1.useCallback)(() => {
+        stopPolling();
+        if (!native)
+            return;
+        pollRef.current = setInterval(async () => {
+            try {
+                const state = await native.getState();
+                setIsRunning(state.isRunning);
+                setTrackingState(state.trackingState);
+            }
+            catch {
+                // Bridge errors during tear-down are expected; ignore.
+            }
+        }, STATE_POLL_INTERVAL_MS);
+    }, [native, stopPolling]);
+    // Always tear down the poll on unmount.
+    (0, react_1.useEffect)(() => stopPolling, [stopPolling]);
+    const start = (0, react_1.useCallback)(async () => {
+        if (!native) {
+            throw new Error('useARSession: RNSARSession native module unavailable');
+        }
+        await native.start();
+        setIsRunning(true);
+        startPolling();
+    }, [native, startPolling]);
+    const stop = (0, react_1.useCallback)(async () => {
+        if (!native)
+            return;
+        stopPolling();
+        await native.stop();
+        setIsRunning(false);
+        setTrackingState(ARTrackingState.NotAvailable);
+    }, [native, stopPolling]);
+    const getFramePoses = (0, react_1.useCallback)(async () => {
+        if (!native)
+            return [];
+        return native.snapshotPoseLog();
+    }, [native]);
+    const clearPoseLog = (0, react_1.useCallback)(async () => {
+        if (!native)
+            return;
+        await native.clearPoseLog();
+    }, [native]);
+    return {
+        isAvailable,
+        isRunning,
+        trackingState,
+        start,
+        stop,
+        getFramePoses,
+        clearPoseLog,
+    };
+}
+//# sourceMappingURL=useARSession.js.map

package/dist/camera/ARCameraView.d.ts

@@ -0,0 +1,93 @@
+/**
+ * ARCameraView — AR-backed alternative to ``<CameraView>`` for
+ * audits that need pose-aware capture (panorama mode, packet
+ * detection).  Renders the ARKit camera feed via the native
+ * `RNSARCameraView` UIView; the underlying ARSession is the
+ * SDK singleton (`RNSARSession.shared`), shared between the
+ * preview and the pose log that feeds Phase 5 stitching + Phase 6
+ * measurement.
+ *
+ * Why a separate component (vs. a polymorphic CameraView)?
+ *   1. **Different imperative API.** The vision-camera-backed
+ *      CameraView exposes `takePhoto / startRecording` via its ref
+ *      (Phase 5 will add equivalents to this component, but they
+ *      route through ARFrame.capturedImage + AVAssetWriter rather
+ *      than vision-camera's APIs).
+ *   2. **Camera-access conflict.** ARKit and AVCaptureSession
+ *      can't share the camera.  Forcing the host to pick one
+ *      component over the other (instead of toggling a prop on a
+ *      shared component) makes the conflict impossible to misuse —
+ *      you can't accidentally mount both at the same time.
+ *   3. **Lifecycle clarity.** The native side starts the AR
+ *      session in `didMoveToWindow`.  Mount = start, unmount =
+ *      stop.  No flag-twiddling.
+ *
+ * This component is preview-only in Phase 4.4.  Photo + video
+ * capture come in Phase 5 (Step 5 of the AR design plan).  Until
+ * then, the host's panorama capture flow continues to use
+ * vision-camera; ARCameraView is opt-in via a settings flag for
+ * developer verification.
+ */
+import React from 'react';
+import { type ViewStyle } from 'react-native';
+export interface ARCameraViewProps {
+    /** Layout style, typically `StyleSheet.absoluteFill` or `flex: 1`. */
+    style?: ViewStyle;
+    /**
+     * Optional themed guidance banner shown over the preview at the
+     * top, mirrors the `<CameraView>` prop so host apps can swap
+     * components without rewriting their guidance text plumbing.
+     */
+    guidance?: string;
+}
+/**
+ * Imperative handle exposed via the ref — shape mirrors the subset
+ * of vision-camera's `Camera` ref methods that the host's
+ * `useCapture` / `useVideoCapture` hooks call.  Hosts can pass the
+ * SAME ref to those hooks as they do for the vision-camera path,
+ * with no branching required.
+ *
+ * Note we do NOT exhaustively mirror vision-camera's API surface —
+ * only the methods the panorama capture flow uses today.  As the
+ * SDK grows AR-aware features, methods are added here.
+ */
+export interface ARCameraViewHandle {
+    /**
+     * Capture the latest ARFrame as a JPEG.  Resolves with a
+     * vision-camera-compatible PhotoFile (`{ path, width, height,
+     * isMirrored, isRawPhoto }`).  Native generates a temp path —
+     * caller does NOT need to construct one.
+     */
+    takePhoto: (options?: {
+        quality?: number;
+    }) => Promise<{
+        path: string;
+        width: number;
+        height: number;
+        isMirrored: boolean;
+        isRawPhoto: boolean;
+    }>;
+    /**
+     * Begin recording AR frames into an mp4.  Mirrors vision-camera's
+     * callback-based API: takes `onRecordingFinished` /
+     * `onRecordingError` handlers; the actual VideoFile is delivered
+     * via `onRecordingFinished` AFTER the host calls `stopRecording`.
+     *
+     * Synchronous return (void) — useVideoCapture wraps it in a
+     * Promise on top of the callbacks.
+     */
+    startRecording: (options: {
+        onRecordingFinished?: (video: {
+            path: string;
+            duration: number;
+            size: number;
+            width: number;
+            height: number;
+        }) => void;
+        onRecordingError?: (err: Error) => void;
+    }) => void;
+    /** Finalise the in-progress recording. */
+    stopRecording: () => Promise<void>;
+}
+export declare const ARCameraView: React.ForwardRefExoticComponent<ARCameraViewProps & React.RefAttributes<ARCameraViewHandle>>;
+//# sourceMappingURL=ARCameraView.d.ts.map