capacitor-camera-view 2.3.1 → 3.0.0

package/dist/esm/definitions.d.ts

@@ -2,12 +2,21 @@ import type { PermissionState, PluginListenerHandle } from '@capacitor/core';
 /**
  * Main plugin interface for Capacitor Camera View functionality.
  *
+ * When a method below rejects, the resulting error carries a `code` property
+ * set to one of the stable `CameraErrorCode` strings so consumers can
+ * `switch` on `error.code` instead of matching on the human-readable message.
+ * See the `CameraErrorCode` type for the full vocabulary, including the one
+ * divergence on web for methods with no web implementation.
+ *
  * @since 1.0.0
  */
 export interface CameraViewPlugin {
     /**
      * Start the camera view with optional configuration.
      *
+     * Rejects if a camera session is already running. Call `stop()` first if you need to
+     * start a new session with different options.
+     *
      * @param options - Configuration options for the camera session
      * @returns A promise that resolves when the camera has started
      *
@@ -38,7 +47,9 @@ export interface CameraViewPlugin {
      *
      * @since 1.0.0
      */
-    capture<T extends CaptureOptions>(options: T): Promise<CaptureResponse<T>>;
+    capture<T extends CaptureOptions = CaptureOptions & {
+        saveToFile?: undefined;
+    }>(options?: T): Promise<CaptureResponse<T>>;
     /**
      * Captures a frame from the current camera preview without using the full camera capture pipeline.
      *
@@ -55,7 +66,9 @@ export interface CameraViewPlugin {
      *
      * @since 1.0.0
      */
-    captureSample<T extends CaptureOptions>(options: T): Promise<CaptureResponse<T>>;
+    captureSample<T extends CaptureOptions = CaptureOptions & {
+        saveToFile?: undefined;
+    }>(options?: T): Promise<CaptureResponse<T>>;
     /**
      * Start recording video from the current camera.
      * Camera must be running. Throws if already recording.
@@ -78,6 +91,11 @@ export interface CameraViewPlugin {
     /**
      * Switch between front and back camera.
      *
+     * Rejects with `RECORDING_ALREADY_IN_PROGRESS` while a video recording is active, on
+     * iOS, Android, and web alike: swapping the camera input/device mid-recording would
+     * either drop the audio track or interrupt the recording outright, so the recording is
+     * left intact and must be stopped before flipping.
+     *
      * @returns A promise that resolves when the camera has been flipped
      *
      * @since 1.0.0
@@ -94,6 +112,14 @@ export interface CameraViewPlugin {
     /**
      * Get current zoom level information and available range.
      *
+     * On iOS, when the camera is a virtual device (e.g. the triple camera enabled via
+     * `useTripleCameraIfAvailable`), the returned values are in the device's raw zoom domain and are
+     * not UI multipliers like "0.5x"/"1x"/"2x". A `min` of `1.0` corresponds to the widest constituent
+     * lens (the ultra-wide "0.5x" lens), so a session started at the default zoom reports a `current`
+     * of the wide-lens switch-over factor (typically `2.0`) rather than `1.0`. Treat these numbers as
+     * device-relative and derive the usable range from `min`/`max` instead of assuming `1.0` is the
+     * default.
+     *
      * @remarks
      * Make sure the camera is properly initialized before calling this method. Otherwise, this might
      * lead to returning default values on android.
@@ -106,6 +132,10 @@ export interface CameraViewPlugin {
     /**
      * Set the camera zoom level.
      *
+     * On iOS virtual devices (e.g. the triple camera) `level` is a raw device zoom factor, not a UI
+     * multiplier. Derive valid values from the `min`/`max` returned by `getZoom()` rather than assuming
+     * `1.0` maps to the wide "1x" lens.
+     *
      * @param options - Zoom configuration options
      * @param options.level - The zoom level to set
      * @param options.ramp - Whether to animate the zoom level change, defaults to false (iOS only)
@@ -121,6 +151,44 @@ export interface CameraViewPlugin {
         level: number;
         ramp?: boolean;
     }): Promise<void>;
+    /**
+     * Focus and meter the camera at a specific point (tap-to-focus).
+     *
+     * Because the WebView sits above the native camera preview and consumes every
+     * touch, the native preview can never receive tap gestures itself. Instead,
+     * the app catches the tap in the DOM and forwards its coordinates here; since
+     * the native preview is always rendered fullscreen behind the WebView, the
+     * mapping to the sensor is deterministic.
+     *
+     * The camera runs a one-shot focus/exposure at the given point and then
+     * automatically restores continuous auto-focus/auto-exposure (immediately on a
+     * subsequent tap, or after a short timeout), so focus is never left
+     * permanently locked.
+     *
+     * @param options - The point to focus on
+     * @param options.x - The horizontal coordinate in CSS/viewport pixels, measured
+     *   from the left edge of the viewport. This is the same coordinate space the
+     *   plugin emits for barcode `boundingRect`, just in the opposite direction.
+     * @param options.y - The vertical coordinate in CSS/viewport pixels, measured
+     *   from the top edge of the viewport.
+     * @returns A promise that resolves when the focus/metering point has been applied
+     *
+     * @remarks
+     * On fixed-focus cameras (e.g. some front cameras) the plugin degrades to
+     * exposure-only metering where possible. If neither focus nor exposure metering
+     * at a point is supported, the promise rejects with the `FOCUS_NOT_SUPPORTED`
+     * error code. Rejects with `SESSION_NOT_RUNNING` when the camera is not running.
+     *
+     * Not supported on web: this method rejects with an `unimplemented` error there,
+     * because the `pointsOfInterest` media-track constraint has effectively no
+     * browser support.
+     *
+     * @since 3.0.0
+     */
+    setFocusPoint(options: {
+        x: number;
+        y: number;
+    }): Promise<void>;
     /**
      * Get current flash mode setting.
      *
@@ -182,11 +250,13 @@ export interface CameraViewPlugin {
      * functionality. This method will throw an exception if torch is not supported.
      *
      * The torch provides continuous illumination, unlike flash which only activates during photo capture.
-     * On iOS, you can control the torch intensity level. On Android, the torch is either on or off.
+     * You can control the torch intensity level on both iOS and, on API 33+ devices with
+     * multi-level torch hardware, Android. On older Android versions or single-level torch
+     * hardware, `level` is best-effort and ignored - the torch is simply switched on or off.
      *
      * @param options - Torch configuration options
      * @param options.enabled - Whether to enable or disable the torch
-     * @param options.level - The torch intensity level (0.0 to 1.0, iOS only). Defaults to 1.0 when enabled
+     * @param options.level - The torch intensity level (0.0 to 1.0). Defaults to 1.0 when enabled
      * @returns A promise that resolves when the torch mode has been set
      *
      * @since 1.2.0
@@ -221,6 +291,15 @@ export interface CameraViewPlugin {
      * Listen for barcode detection events.
      * This event is emitted when a barcode is detected in the camera preview.
      *
+     * @remarks
+     * Events are rate-controlled to avoid flooding the bridge. Repeated detections
+     * of the same barcode (identical `value` and `type`) are suppressed while the
+     * code stays in view: after an initial event, the same code re-emits at most
+     * once per ~500 ms suppression window. Pointing the camera at a different
+     * barcode (a different `value` or `type`) emits immediately rather than waiting
+     * for the window to elapse. This behavior is consistent across iOS, Android,
+     * and web.
+     *
      * @param eventName - The name of the event to listen for ('barcodeDetected')
      * @param listenerFunc - The callback function to execute when a barcode is detected
      * @returns A promise that resolves with an event subscription
@@ -228,15 +307,72 @@ export interface CameraViewPlugin {
      * @since 1.0.0
      */
     addListener(eventName: 'barcodeDetected', listenerFunc: (data: BarcodeDetectionData) => void): Promise<PluginListenerHandle>;
+    /**
+     * Listen for camera interruption events.
+     *
+     * Emitted when the capture session is interrupted by the system, for example
+     * an incoming phone call, another app claiming the camera or microphone,
+     * losing the camera in iPad Split View, or system pressure. The preview
+     * typically freezes for the duration of the interruption.
+     *
+     * @remarks
+     * Currently emitted on iOS only. Android and web will follow.
+     *
+     * @param eventName - The name of the event to listen for ('cameraInterrupted')
+     * @param listenerFunc - The callback function to execute when the camera is interrupted
+     * @returns A promise that resolves with an event subscription
+     *
+     * @since 3.0.0
+     */
+    addListener(eventName: 'cameraInterrupted', listenerFunc: (data: CameraInterruptedData) => void): Promise<PluginListenerHandle>;
+    /**
+     * Listen for camera resume events.
+     *
+     * Emitted when a previous interruption ends and the capture session resumes,
+     * for example after an incoming phone call finishes. Pair this with
+     * `cameraInterrupted` to update your UI when the preview recovers.
+     *
+     * @remarks
+     * Currently emitted on iOS only. Android and web will follow.
+     *
+     * @param eventName - The name of the event to listen for ('cameraResumed')
+     * @param listenerFunc - The callback function to execute when the camera resumes
+     * @returns A promise that resolves with an event subscription
+     *
+     * @since 3.0.0
+     */
+    addListener(eventName: 'cameraResumed', listenerFunc: () => void): Promise<PluginListenerHandle>;
+    /**
+     * Listen for camera runtime error events.
+     *
+     * Emitted when the capture session hits a runtime error. When the underlying
+     * media services are reset, the plugin restarts the session automatically, so
+     * this event is primarily informational for logging and diagnostics.
+     *
+     * @remarks
+     * Currently emitted on iOS only. Android and web will follow.
+     *
+     * @param eventName - The name of the event to listen for ('cameraRuntimeError')
+     * @param listenerFunc - The callback function to execute when a runtime error occurs
+     * @returns A promise that resolves with an event subscription
+     *
+     * @since 3.0.0
+     */
+    addListener(eventName: 'cameraRuntimeError', listenerFunc: (data: CameraRuntimeErrorData) => void): Promise<PluginListenerHandle>;
     /**
      * Remove all listeners for this plugin.
      *
-     * @param eventName - Optional event name to remove listeners for
+     * @remarks
+     * This removes *every* listener registered on this plugin instance, regardless of event
+     * name, on iOS, Android, and web. There is no way to remove listeners for a single event
+     * name only; if you need that, keep track of the `PluginListenerHandle` returned by
+     * `addListener()` and call `remove()` on it instead.
+     *
      * @returns A promise that resolves when the listeners are removed
      *
      * @since 1.0.0
      */
-    removeAllListeners(eventName?: string): Promise<void>;
+    removeAllListeners(): Promise<void>;
 }
 /**
  * Position options for the camera.
@@ -265,6 +401,28 @@ export type FlashMode = 'off' | 'on' | 'auto';
  * @since 2.3.0
  */
 export type VideoRecordingQuality = 'lowest' | 'sd' | 'hd' | 'fhd' | 'uhd' | 'highest';
+/**
+ * Sensor aspect ratio for a camera session, applied consistently to both the
+ * live preview stream and photo capture.
+ * - '4:3': The native photo aspect ratio of most mobile camera sensors
+ * - '16:9': The typical video aspect ratio
+ *
+ * @since 3.0.0
+ */
+export type CameraAspectRatio = '4:3' | '16:9';
+/**
+ * How the camera preview is scaled to fill its container when the sensor
+ * aspect ratio differs from the container's aspect ratio.
+ * - 'cover': The preview fills the whole container, center-cropping the frame
+ *   so no empty bars are shown. Parts of the frame outside the container are
+ *   hidden from the preview (long-standing default behavior).
+ * - 'fit': The whole sensor frame is scaled to fit inside the container
+ *   (letterboxed), so the user sees the entire frame they are about to
+ *   capture. Empty bars appear on the short axis.
+ *
+ * @since 3.0.0
+ */
+export type PreviewScaleMode = 'cover' | 'fit';
 /**
  * Represents a physical camera device on the device.
  *
@@ -321,6 +479,8 @@ export type BarcodeType =
  | 'code39Mod43'
 /** Code 93 barcode */
  | 'code93'
+/** Codabar barcode. Not detectable on iOS below 15.4; the deployment target is 16, so it is available on all supported iOS versions. */
+ | 'codabar'
 /** EAN-8 barcode */
  | 'ean8'
 /** EAN-13 barcode */
@@ -335,6 +495,16 @@ export type BarcodeType =
  | 'aztec'
 /** Data Matrix code */
  | 'dataMatrix'
+/**
+ * UPC-A barcode.
+ *
+ * Detected as a distinct `upcA` type on Android (ML Kit) and web
+ * (BarcodeDetector). iOS cannot: AVFoundation has no UPC-A metadata type and
+ * reports UPC-A codes as `ean13` (a UPC-A value is an EAN-13 with a leading
+ * `0`), so requesting `upcA` on iOS has no effect and such codes arrive as
+ * `ean13`.
+ */
+ | 'upcA'
 /** UPC-E barcode */
  | 'upce';
 /**
@@ -369,7 +539,12 @@ export interface CameraSessionConfiguration {
      */
     deviceId?: string;
     /**
-     * Whether to use the triple camera if available (iPhone Pro models only)
+     * Whether to use the triple camera if available (iPhone Pro models only).
+     *
+     * The session starts directly on the virtual device, which lets iOS switch
+     * between the ultra-wide, wide and telephoto lenses automatically. Takes
+     * precedence over `preferredCameraDeviceTypes` for the rear camera.
+     *
      * @default false
      */
     useTripleCameraIfAvailable?: boolean;
@@ -386,10 +561,115 @@ export interface CameraSessionConfiguration {
      */
     preferredCameraDeviceTypes?: CameraDeviceType[];
     /**
-     * The initial zoom factor to use
+     * The sensor aspect ratio to use for the camera session, applied to both
+     * the live preview stream and photo capture so the captured image matches
+     * the framing the user sees.
+     *
+     * **Preview-vs-capture framing contract** (identical on iOS, Android and
+     * web when this option is set):
+     *
+     * - By default (`previewScaleMode: 'cover'`) the preview fills its container
+     *   (the fullscreen view behind the WebView on iOS/Android, the container
+     *   element on web) using cover semantics: when the chosen sensor ratio
+     *   differs from the container ratio, the preview is center-cropped to fill
+     *   it — never letterboxed. `capture()` returns the full sensor-ratio image
+     *   (matching this option), NOT the on-screen crop. Parts of the image that
+     *   were cropped out of the preview by cover-scaling are therefore included
+     *   in the capture.
+     * - With `previewScaleMode: 'fit'` the whole sensor frame is letterboxed to
+     *   fit inside the container, so the preview shows exactly the full captured
+     *   frame: `capture()` returns what the preview shows, with nothing cropped
+     *   out of view. See {@link previewScaleMode} for the letterbox-background
+     *   note.
+     *
+     * When this option is omitted, each platform keeps its long-standing
+     * default behavior: iOS uses the sensor's native photo format (4:3),
+     * Android prefers 16:9 with an automatic fallback, and web requests a
+     * 16:9 stream and returns the visible (cover-cropped) preview region from
+     * `capture()` instead of the full frame. Captured output stays JPEG on all
+     * platforms either way.
+     *
+     * @default undefined - platform default (see above)
+     * @since 3.0.0
+     */
+    aspectRatio?: CameraAspectRatio;
+    /**
+     * Optional capture-resolution hint: an upper bound, in pixels, for the
+     * longer edge of captured photos. The platform picks the largest supported
+     * capture resolution whose longer edge does not exceed this value (falling
+     * back to the closest supported resolution when none fits) while keeping
+     * the configured `aspectRatio`.
+     *
+     * This is a best-effort hint: the exact output dimensions depend on the
+     * resolutions the sensor/browser actually supports.
+     *
+     * - iOS: constrains `AVCapturePhotoOutput.maxPhotoDimensions`. Only affects
+     *   `capture()`; `captureSample()` keeps sampling the preview stream.
+     * - Android: bounds the CameraX ImageCapture resolution. Only affects
+     *   `capture()`.
+     * - Web: used as the ideal `getUserMedia` width constraint, so it affects
+     *   the stream (preview and capture alike).
+     *
+     * @example 1280 // capture photos at most 1280px wide (longer edge)
+     * @default undefined - platform default resolution
+     * @since 3.0.0
+     */
+    captureMaxDimension?: number;
+    /**
+     * How the live preview is scaled into its container when the sensor aspect
+     * ratio differs from the container's aspect ratio.
+     *
+     * - `'cover'` (default): the preview fills the container, center-cropping the
+     *   frame. This is the long-standing behavior and is unchanged when the
+     *   option is omitted.
+     * - `'fit'`: the whole sensor frame is scaled to fit inside the container
+     *   (letterboxed), so the user sees the entire frame they are about to
+     *   capture. In `fit` mode the preview shows exactly the full captured frame,
+     *   and `capture()` returns what the preview shows.
+     *
+     * Applied consistently on iOS (`AVCaptureVideoPreviewLayer.videoGravity`),
+     * Android (`PreviewView.ScaleType`) and web (`object-fit`). Barcode
+     * `boundingRect` and `setFocusPoint` coordinates stay correct in both modes.
+     *
+     * **Letterbox background**: the empty bars shown in `fit` mode are not painted
+     * by the plugin — they show whatever is visually behind/around the preview.
+     * On iOS/Android that is the app's own background showing through the
+     * transparent WebView; on web it is the container element's background. Style
+     * that background (e.g. a black or themed color) to control how the
+     * letterbox bars look.
+     *
+     * @default 'cover'
+     * @since 3.0.0
+     */
+    previewScaleMode?: PreviewScaleMode;
+    /**
+     * The initial zoom factor to use.
+     *
+     * Expressed relative to the wide-angle lens, so `1.0` is the familiar "1x" field of view on every
+     * camera. On iOS virtual devices whose raw `1.0` is the ultra-wide lens (e.g. the triple camera
+     * enabled via `useTripleCameraIfAvailable`) the factor is scaled into the device's own zoom domain,
+     * which is why `getZoom()` reports a larger `current` than the value passed here.
+     *
      * @default 1.0
      */
     zoomFactor?: number;
+    /**
+     * Prioritize photo quality over capture responsiveness (iOS 17+ only).
+     *
+     * By default the plugin opts into the iOS 17+ responsive-capture pipeline
+     * (zero-shutter-lag, responsive capture and fast capture prioritization) so
+     * consecutive `capture()` calls have a lower shot-to-shot latency. Rapid
+     * consecutive captures may then be delivered at a slightly reduced quality
+     * instead of queueing.
+     *
+     * Set this to `true` to opt out of that behavior and always prioritize photo
+     * quality. Has no effect on iOS versions or hardware without support for the
+     * responsive-capture APIs, and no effect on Android or Web.
+     *
+     * @default false
+     * @since 3.0.0
+     */
+    prioritizeQuality?: boolean;
     /**
      * Optional HTML ID of the container element where the camera view should be rendered.
      * If not provided, the camera view will be appended to the document body. Web only.
@@ -404,10 +684,15 @@ export interface CameraSessionConfiguration {
  */
 export interface CaptureOptions {
     /**
-     * The JPEG quality of the captured photo/sample on a scale of 0-100
+     * The JPEG quality of the captured photo/sample on a scale of 0-100. Cross-platform note:
+     * for `quality >= 90`, iOS returns the original, unmodified JPEG produced by the camera
+     * hardware instead of re-encoding it, to avoid unnecessary quality loss and CPU overhead.
+     * Android and Web always encode at the exact requested quality. As a result, the same
+     * `quality` value (90-100) can produce different file sizes on iOS versus Android/Web.
+     * @default 90
      * @since 1.1.0
      */
-    quality: number;
+    quality?: number;
     /**
      * If true, saves to a temporary file and returns the web path instead of base64.
      * The web path can be used to set the src attribute of an image for efficient loading and rendering.
@@ -444,12 +729,23 @@ export interface VideoRecordingOptions {
  */
 export interface VideoRecordingResponse {
     /**
-     * Web-accessible path to the recorded video file.
-     * On web, this is a blob URL.
-     * On iOS/Android, this is a path accessible via Capacitor's filesystem.
+     * Web-accessible path to the recorded video file that can be used to set the
+     * `src` attribute of a video element for efficient loading and rendering.
+     * On web, this is a blob URL created with `URL.createObjectURL()`; the plugin does not
+     * revoke it automatically, so call `URL.revokeObjectURL(webPath)` once you are done with
+     * it (e.g. after playback or upload) to release the underlying memory.
+     * On iOS/Android, this is a Capacitor bridge path served by the local web server and does
+     * not need to be revoked.
      * @since 2.3.0
      */
     webPath: string;
+    /**
+     * The full, platform-specific file URL (`file://...`) to the recorded video,
+     * usable with the Filesystem API or `Capacitor.convertFileSrc()`.
+     * Native only (iOS/Android); `undefined` on web.
+     * @since 2.4.0
+     */
+    path?: string;
 }
 /**
  * Response for checking if the camera view is running.
@@ -461,18 +757,59 @@ export interface IsRunningResponse {
     isRunning: boolean;
 }
 /**
- * Response for capturing a photo
- * This will contain either a base64 encoded string or a web path to the captured photo,
- * depending on the `saveToFile` option in the CaptureOptions.
+ * The file-path shaped result returned when `saveToFile` is `true`.
  * @since 1.0.0
  */
-export type CaptureResponse<T extends CaptureOptions = CaptureOptions> = T['saveToFile'] extends true ? {
-    /** The web path to the captured photo that can be used to set the src attribute of an image for efficient loading and rendering (when saveToFile is true) */
+export interface CaptureFileResult {
+    /**
+     * The web path to the captured photo that can be used to set the src attribute of an image
+     * for efficient loading and rendering (when saveToFile is true).
+     *
+     * On web, this is a blob URL created with `URL.createObjectURL()`. The plugin does not revoke
+     * it automatically; once you are done with it (e.g. after the image has been displayed or
+     * uploaded), call `URL.revokeObjectURL(webPath)` to release the underlying memory. On
+     * iOS/Android this is a Capacitor bridge path served by the local web server and does not
+     * need to be revoked.
+     */
     webPath: string;
-} : {
+    /**
+     * The full, platform-specific file URL (`file://...`) to the captured photo,
+     * usable with the Filesystem API or `Capacitor.convertFileSrc()`.
+     * Native only (iOS/Android); `undefined` on web.
+     * @since 2.4.0
+     */
+    path?: string;
+}
+/**
+ * The base64 shaped result returned when `saveToFile` is `false` or `undefined`.
+ * @since 1.0.0
+ */
+export interface CaptureBase64Result {
     /** The base64 encoded string of the captured photo (when saveToFile is false or undefined) */
     photo: string;
-};
+}
+/**
+ * Response for capturing a photo
+ * This will contain either a base64 encoded string or a web path to the captured photo,
+ * depending on the `saveToFile` option in the CaptureOptions.
+ *
+ * @remarks
+ * The narrowing is three-way on `saveToFile`:
+ * - a literal `true` narrows to {@link CaptureFileResult}
+ * - a literal `false`, an explicit `undefined`, or an options type that omits the key
+ *   entirely narrows to {@link CaptureBase64Result}
+ * - a non-literal `boolean` (or a `CaptureOptions` with `saveToFile` left generic) resolves
+ *   to the union of both, since the runtime result can't be known at the type level
+ *
+ * @since 1.0.0
+ */
+export type CaptureResponse<T extends CaptureOptions = CaptureOptions> = SaveToFileOf<T> extends true ? CaptureFileResult : SaveToFileOf<T> extends false | undefined ? CaptureBase64Result : CaptureFileResult | CaptureBase64Result;
+/**
+ * `T['saveToFile']` resolves through the `CaptureOptions` constraint to `boolean | undefined`
+ * when `T` omits the key, which would widen the result to the union. Treat an absent key as
+ * `undefined` instead.
+ */
+type SaveToFileOf<T extends CaptureOptions> = 'saveToFile' extends keyof T ? T['saveToFile'] : undefined;
 /**
  * Response for getting available camera devices.
  *
@@ -485,14 +822,19 @@ export interface GetAvailableDevicesResponse {
 /**
  * Response for getting zoom level information.
  *
+ * @remarks
+ * On iOS virtual devices (e.g. the triple camera) these values are in the device's raw zoom domain,
+ * not UI multipliers: `min` of `1.0` is the ultra-wide ("0.5x") lens and `current` reports the
+ * wide-lens switch-over factor rather than `1.0` at the default zoom. See {@link CameraViewPlugin.getZoom}.
+ *
  * @since 1.0.0
  */
 export interface GetZoomResponse {
-    /** The minimum zoom level supported */
+    /** The minimum zoom level supported. On iOS virtual devices `1.0` maps to the ultra-wide lens. */
     min: number;
-    /** The maximum zoom level supported */
+    /** The maximum zoom level supported. On iOS virtual devices this is a raw device factor (capped at a 10x wide-equivalent zoom). */
     max: number;
-    /** The current zoom level */
+    /** The current zoom level. On iOS virtual devices this is a raw device factor, not a UI multiplier. */
     current: number;
 }
 /**
@@ -530,7 +872,13 @@ export interface IsTorchAvailableResponse {
 export interface GetTorchModeResponse {
     /** Indicates if the torch is currently enabled */
     enabled: boolean;
-    /** The current torch intensity level (0.0 to 1.0, iOS only). Always 1.0 on Android when enabled */
+    /**
+     * The current torch intensity level (0.0 to 1.0).
+     *
+     * On Android this reflects the real hardware strength only on API 33+ devices with
+     * multi-level torch hardware; below API 33, or on single-level hardware, the torch is
+     * binary, so this is always 1.0 when enabled and 0.0 when off.
+     */
     level: number;
 }
 /**
@@ -559,14 +907,40 @@ export interface BarcodeDetectionData {
      * expose a separate display value, so this property is only emitted on Android.
      */
     displayValue?: string;
-    /** The type/format of the barcode (e.g., 'qr', 'code128', etc.) */
-    type: string;
+    /**
+     * The type/format of the detected barcode.
+     *
+     * For formats that are part of the `BarcodeType` union, all platforms emit
+     * identical values, so scanning the same barcode yields the same `type` on
+     * web, iOS, and Android (e.g. `'qr'`, `'code128'`, `'dataMatrix'`).
+     *
+     * The type is `BarcodeType | string` rather than `BarcodeType` because a
+     * platform detector can occasionally report a format that has no
+     * cross-platform union member; in that case the raw platform string is
+     * forwarded unchanged instead of being dropped. In practice this is Android's
+     * `'unknown'` (ML Kit's `FORMAT_UNKNOWN`) and the equivalent `'unknown'` from
+     * the web BarcodeDetector. Narrow against the `BarcodeType` members you care
+     * about and treat anything else as an opaque string.
+     *
+     * Platform-specific notes:
+     * - iOS distinguishes `interleaved2of5` from `itf14`, whereas Android and web
+     *   cannot tell them apart and always report `itf14` for their shared
+     *   interleaved-2-of-5/ITF detector format.
+     * - UPC-A is reported as `'upcA'` on Android and web, but as `'ean13'` on iOS:
+     *   AVFoundation has no UPC-A metadata type and surfaces UPC-A codes as EAN-13
+     *   (a UPC-A value is an EAN-13 with a leading `0`). This is a hardware/OS
+     *   limitation, not a normalization choice.
+     * - Codabar is reported as `'codabar'` on all three platforms.
+     */
+    type: BarcodeType | string;
     /** The bounding rectangle of the barcode in the camera frame. */
     boundingRect: BoundingRect;
 }
 /**
  * Rectangle defining the boundary of the barcode in the camera frame.
- * Coordinates are normalized between 0 and 1 relative to the camera frame.
+ * Coordinates are given in display/CSS pixels within the webview (display)
+ * coordinate space, not normalized values. This lets you position an overlay
+ * directly on top of the detected barcode without further scaling.
  *
  * @since 1.0.0
  */
@@ -580,6 +954,98 @@ export interface BoundingRect {
     /** Height of the bounding rectangle (should match the actual height of the barcode) */
     height: number;
 }
+/**
+ * Reason why the camera session was interrupted.
+ *
+ * Mirrors `AVCaptureSession.InterruptionReason` on iOS. Unknown or future
+ * reasons fall back to `'unknown'`.
+ *
+ * @since 3.0.0
+ */
+export type CameraInterruptionReason = 
+/** The video device is not available because the app is in the background */
+'videoDeviceNotAvailableInBackground'
+/** The audio device is in use by another client (e.g. a phone call) */
+ | 'audioDeviceInUseByAnotherClient'
+/** The video device is in use by another client */
+ | 'videoDeviceInUseByAnotherClient'
+/** The video device is not available while multiple foreground apps share the screen (iPad Split View) */
+ | 'videoDeviceNotAvailableWithMultipleForegroundApps'
+/** The video device is not available due to system pressure (e.g. thermal) */
+ | 'videoDeviceNotAvailableDueToSystemPressure'
+/** The interruption reason could not be determined */
+ | 'unknown';
+/**
+ * Data for a camera interruption event.
+ *
+ * @since 3.0.0
+ */
+export interface CameraInterruptedData {
+    /** The reason the camera session was interrupted. */
+    reason: CameraInterruptionReason;
+}
+/**
+ * Data for a camera runtime error event.
+ *
+ * @since 3.0.0
+ */
+export interface CameraRuntimeErrorData {
+    /** A human-readable description of the runtime error. */
+    message: string;
+    /**
+     * The underlying platform error code, when available.
+     * On iOS this is the `AVError` code.
+     */
+    code?: number;
+}
+/**
+ * Stable error codes returned as the `code` property on the error of a
+ * rejected plugin call.
+ *
+ * These codes are part of the plugin's public contract: they are safe to
+ * `switch` on and will not change between releases the way human-readable
+ * error messages might. Where the same failure class exists across
+ * platforms, iOS, Android, and web emit the same code string.
+ *
+ * Emitted on iOS, Android, and web. One divergence: on web, methods that
+ * have no web implementation (e.g. `setFocusPoint()`, `setTorchMode()`)
+ * reject via Capacitor's own not-implemented convention instead of one of
+ * the codes below - `error.code` is the string `'UNIMPLEMENTED'`, not a
+ * `CameraErrorCode`.
+ *
+ * - 'CAMERA_UNAVAILABLE': No available camera for the requested position.
+ * - 'CONFIGURATION_FAILED': Failed to configure the camera session.
+ * - 'FRAME_CAPTURE_ERROR': Failed to capture a frame from the camera.
+ * - 'INPUT_ADDITION_FAILED': Failed to add an input to the capture session.
+ * - 'OUTPUT_ADDITION_FAILED': Failed to add an output to the capture session.
+ * - 'PHOTO_OUTPUT_ERROR': An error occurred while capturing a photo.
+ * - 'PHOTO_OUTPUT_NOT_CONFIGURED': The photo output has not been configured.
+ * - 'SESSION_NOT_RUNNING': The capture session is not currently running. Call `start()` first.
+ * - 'SESSION_ALREADY_RUNNING': A camera session is already running. Call `stop()` before starting a new one.
+ * - 'UNSUPPORTED_FLASH_MODE': The requested flash mode is not supported by the current camera.
+ * - 'TORCH_UNAVAILABLE': Torch is not available on this device or camera position.
+ * - 'ZOOM_FACTOR_OUT_OF_RANGE': The requested zoom factor is out of the supported range.
+ * - 'FOCUS_NOT_SUPPORTED': The current camera cannot focus or meter at a point (e.g. a fixed-focus camera).
+ * - 'PERMISSION_DENIED': Camera or microphone access has been denied.
+ * - 'DEVICE_LOCKED': The camera device is currently locked by another process.
+ * - 'RECORDING_ALREADY_IN_PROGRESS': A video recording is already in progress.
+ * - 'NO_RECORDING_IN_PROGRESS': `stopRecording()` was called but no recording is in progress.
+ * - 'AUDIO_DEVICE_UNAVAILABLE': No microphone is available on this device.
+ * - 'AUDIO_INPUT_ADDITION_FAILED': Failed to add the microphone input to the capture session.
+ * - 'CAPTURE_IN_PROGRESS': A capture is already in progress.
+ * - 'CAPTURE_TIMEOUT': Timed out waiting for a camera frame.
+ * - 'WEBVIEW_UNAVAILABLE': Could not find the web view to render the camera preview into.
+ * - 'INVALID_ARGUMENT': An argument passed to the method call was missing or invalid.
+ * - 'IMAGE_COMPRESSION_FAILED': Failed to compress the captured image.
+ * - 'PATH_CONVERSION_FAILED': Failed to create a web-accessible path for a captured file.
+ * - 'FILE_WRITE_FAILED': Failed to write the captured file to disk.
+ * - 'CAPTURE_OUTPUT_MISSING': The capture completed but produced no output data.
+ * - 'LIFECYCLE_OWNER_MISSING': (Android only) The WebView's context is not a `LifecycleOwner`, so the camera session cannot be bound.
+ * - 'UNKNOWN_ERROR': An unexpected error that does not map to a known camera error (e.g. an underlying OS error).
+ *
+ * @since 3.0.0
+ */
+export type CameraErrorCode = 'CAMERA_UNAVAILABLE' | 'CONFIGURATION_FAILED' | 'FRAME_CAPTURE_ERROR' | 'INPUT_ADDITION_FAILED' | 'OUTPUT_ADDITION_FAILED' | 'PHOTO_OUTPUT_ERROR' | 'PHOTO_OUTPUT_NOT_CONFIGURED' | 'SESSION_NOT_RUNNING' | 'SESSION_ALREADY_RUNNING' | 'UNSUPPORTED_FLASH_MODE' | 'TORCH_UNAVAILABLE' | 'ZOOM_FACTOR_OUT_OF_RANGE' | 'FOCUS_NOT_SUPPORTED' | 'PERMISSION_DENIED' | 'DEVICE_LOCKED' | 'RECORDING_ALREADY_IN_PROGRESS' | 'NO_RECORDING_IN_PROGRESS' | 'AUDIO_DEVICE_UNAVAILABLE' | 'AUDIO_INPUT_ADDITION_FAILED' | 'CAPTURE_IN_PROGRESS' | 'CAPTURE_TIMEOUT' | 'WEBVIEW_UNAVAILABLE' | 'INVALID_ARGUMENT' | 'IMAGE_COMPRESSION_FAILED' | 'PATH_CONVERSION_FAILED' | 'FILE_WRITE_FAILED' | 'CAPTURE_OUTPUT_MISSING' | 'LIFECYCLE_OWNER_MISSING' | 'UNKNOWN_ERROR';
 /**
  * Permission types that can be requested.
  * - 'camera': Camera access permission
@@ -599,3 +1065,4 @@ export interface PermissionStatus {
     /** The state of the microphone permission */
     microphone: PermissionState;
 }
+export {};