@capgo/camera-preview 8.5.0 → 8.6.0

package/README.md

@@ -382,6 +382,10 @@ Documentation for the [uploader](https://github.com/Cap-go/capacitor-uploader)
 * [`setVideoCodec(...)`](#setvideocodec)
 * [`getVideoCodec()`](#getvideocodec)
 * [`getSupportedVideoCodecs()`](#getsupportedvideocodecs)
+* [`isVideoStabilizationSupported()`](#isvideostabilizationsupported)
+* [`getSupportedVideoStabilizationModes()`](#getsupportedvideostabilizationmodes)
+* [`getVideoStabilizationMode()`](#getvideostabilizationmode)
+* [`setVideoStabilizationMode(...)`](#setvideostabilizationmode)
 * [`isRunning()`](#isrunning)
 * [`getAvailableDevices()`](#getavailabledevices)
 * [`getZoom()`](#getzoom)
@@ -755,9 +759,9 @@ startRecordVideo(options: CameraPreviewOptions) => Promise<void>
 
 Starts recording a video.
 
-| Param         | Type                                                                  | Description                        |
-| ------------- | --------------------------------------------------------------------- | ---------------------------------- |
-| **`options`** | <code><a href="#camerapreviewoptions">CameraPreviewOptions</a></code> | - The options for video recording. |
+| Param         | Type                                                                  | Description                                                                                                                           |
+| ------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| **`options`** | <code><a href="#camerapreviewoptions">CameraPreviewOptions</a></code> | - The options for video recording. Supports `videoCodec`, `videoStabilizationMode`, `maxDuration`, `maxFileSize`, and `disableAudio`. |
 
 **Since:** 0.0.1
 
@@ -858,6 +862,70 @@ Returns the video codecs supported by the active camera.
 --------------------
 
 
+### isVideoStabilizationSupported()
+
+```typescript
+isVideoStabilizationSupported() => Promise<{ supported: boolean; }>
+```
+
+Checks whether video stabilization is supported by the active camera.
+
+**Returns:** <code>Promise&lt;{ supported: boolean; }&gt;</code>
+
+**Since:** 8.5.2
+
+--------------------
+
+
+### getSupportedVideoStabilizationModes()
+
+```typescript
+getSupportedVideoStabilizationModes() => Promise<{ modes: VideoStabilizationMode[]; }>
+```
+
+Returns the video stabilization modes supported by the active camera.
+
+**Returns:** <code>Promise&lt;{ modes: VideoStabilizationMode[]; }&gt;</code>
+
+**Since:** 8.5.2
+
+--------------------
+
+
+### getVideoStabilizationMode()
+
+```typescript
+getVideoStabilizationMode() => Promise<{ mode: VideoStabilizationMode; }>
+```
+
+Gets the current video stabilization mode.
+
+**Returns:** <code>Promise&lt;{ mode: <a href="#videostabilizationmode">VideoStabilizationMode</a>; }&gt;</code>
+
+**Since:** 8.5.2
+
+--------------------
+
+
+### setVideoStabilizationMode(...)
+
+```typescript
+setVideoStabilizationMode(options: { mode: VideoStabilizationMode; }) => Promise<void>
+```
+
+Sets the video stabilization mode for recording.
+Cannot be changed while a recording is in progress.
+You can also pass `videoStabilizationMode` in `startRecordVideo()` options.
+
+| Param         | Type                                                                                 | Description                       |
+| ------------- | ------------------------------------------------------------------------------------ | --------------------------------- |
+| **`options`** | <code>{ mode: <a href="#videostabilizationmode">VideoStabilizationMode</a>; }</code> | - The desired stabilization mode. |
+
+**Since:** 8.5.2
+
+--------------------
+
+
 ### isRunning()
 
 ```typescript
@@ -1343,6 +1411,7 @@ Defines the configuration options for starting the camera preview.
 | **`maxDuration`**                   | <code>number</code>                                                                | Maximum recording duration in seconds. Recording stops automatically when reached.                                                                                                                                                  |                        |        |
 | **`maxFileSize`**                   | <code>number</code>                                                                | Maximum recording file size in bytes. Recording stops automatically when reached.                                                                                                                                                   |                        |        |
 | **`videoCodec`**                    | <code><a href="#videocodec">VideoCodec</a></code>                                  | Preferred video codec for recording.                                                                                                                                                                                                | <code>"avc1"</code>    |        |
+| **`videoStabilizationMode`**        | <code><a href="#videostabilizationmode">VideoStabilizationMode</a></code>          | Preferred video stabilization mode for recording.                                                                                                                                                                                   | <code>"off"</code>     |        |
 | **`barcodeScanner`**                | <code>boolean \| <a href="#barcodescanneroptions">BarcodeScannerOptions</a></code> | Starts barcode scanning together with the camera preview. Set to `true` or pass options to scan all supported formats. Omit this option to keep barcode scanning disabled at startup.                                               |                        | 8.8.0  |
 
 
@@ -1563,6 +1632,16 @@ Video codec identifiers used when recording.
 <code>'avc1' | 'hvc1' | 'jpeg' | 'apcn' | 'ap4h'</code>
 
 
+#### VideoStabilizationMode
+
+Video stabilization modes used when recording.
+
+On Android only `off` and `standard` are supported.
+On iOS all listed modes may be available when the device supports video stabilization.
+
+<code>'off' | 'standard' | 'cinematic' | 'cinematicExtended' | 'previewOptimized' | 'cinematicExtendedEnhanced' | 'auto' | 'lowLatency'</code>
+
+
 #### BarcodeScannerFormat
 
 <code>'aztec' | 'codabar' | 'code_39' | 'code_93' | 'code_128' | 'data_matrix' | 'ean_8' | 'ean_13' | 'itf' | 'pdf417' | 'qr_code' | 'upc_a' | 'upc_e'</code>

package/android/src/main/java/app/capgo/capacitor/camera/preview/CameraPreview.java

@@ -52,6 +52,7 @@ import com.google.android.gms.location.FusedLocationProviderClient;
 import com.google.android.gms.location.LocationServices;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
@@ -2701,6 +2702,63 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         call.resolve(ret);
     }
 
+    @PluginMethod
+    public void isVideoStabilizationSupported(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        JSObject ret = new JSObject();
+        ret.put("supported", cameraXView.isVideoStabilizationSupported());
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getSupportedVideoStabilizationModes(PluginCall call) {
+        List<String> modes = cameraXView != null ? cameraXView.getSupportedVideoStabilizationModes() : Collections.singletonList("off");
+        JSONArray arr = new JSONArray();
+        for (String mode : modes) {
+            arr.put(mode);
+        }
+        JSObject ret = new JSObject();
+        ret.put("modes", arr);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getVideoStabilizationMode(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        JSObject ret = new JSObject();
+        ret.put("mode", cameraXView.getVideoStabilizationModeSetting());
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void setVideoStabilizationMode(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        String mode = call.getString("mode");
+        if (mode == null) {
+            call.reject("mode is required");
+            return;
+        }
+        try {
+            cameraXView.setVideoStabilizationModeSetting(mode);
+            call.resolve();
+        } catch (IllegalArgumentException e) {
+            call.reject(e.getMessage());
+        } catch (IllegalStateException e) {
+            call.reject(e.getMessage());
+        } catch (Exception e) {
+            call.reject("Failed to set video stabilization mode: " + e.getMessage());
+        }
+    }
+
     @PluginMethod
     public void startRecordVideo(PluginCall call) {
         if (cameraXView == null || !cameraXView.isRunning()) {
@@ -2717,6 +2775,7 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         if (PermissionState.GRANTED.equals(getPermissionState(permissionAlias))) {
             try {
                 applyVideoCodecFromCall(call);
+                applyVideoStabilizationFromCall(call);
                 cameraXView.startRecordVideo(getMaxDurationMillis(call), getMaxFileSize(call));
                 call.resolve();
             } catch (Exception e) {
@@ -2773,6 +2832,13 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         }
     }
 
+    private void applyVideoStabilizationFromCall(PluginCall call) {
+        String mode = call.getString("videoStabilizationMode");
+        if (mode != null && cameraXView != null) {
+            cameraXView.setVideoStabilizationModeSetting(mode);
+        }
+    }
+
     private Long getMaxDurationMillis(PluginCall call) {
         if (!call.getData().has("maxDuration") || call.getData().isNull("maxDuration")) {
             return null;
@@ -2804,6 +2870,7 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         ) {
             try {
                 applyVideoCodecFromCall(call);
+                applyVideoStabilizationFromCall(call);
                 cameraXView.startRecordVideo(getMaxDurationMillis(call), getMaxFileSize(call));
                 call.resolve();
             } catch (Exception e) {

package/android/src/main/java/app/capgo/capacitor/camera/preview/CameraXView.java

@@ -1139,7 +1139,9 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                         recorderBuilder.setVideoCapabilitiesSource(Recorder.VIDEO_CAPABILITIES_SOURCE_CODEC_CAPABILITIES);
                     }
                     Recorder recorder = recorderBuilder.build();
-                    videoCapture = VideoCapture.withOutput(recorder);
+                    VideoCapture.Builder<Recorder> videoCaptureBuilder = new VideoCapture.Builder<>(recorder);
+                    videoCaptureBuilder.setVideoStabilizationEnabled(isVideoStabilizationEnabledForSession());
+                    videoCapture = videoCaptureBuilder.build();
                 }
 
                 // Unbind any existing use cases and bind new ones
@@ -4785,6 +4787,15 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     private static final List<String> ALL_VIDEO_QUALITIES = Arrays.asList("low", "medium", "high", "2160p", "1080p", "720p", "480p", "4:3");
 
     private static final List<String> ALL_VIDEO_CODECS = Arrays.asList("avc1", "hvc1");
+    private static final List<String> ALL_VIDEO_STABILIZATION_MODES = Arrays.asList("off", "standard");
+    private static final List<String> IOS_ONLY_VIDEO_STABILIZATION_MODES = Arrays.asList(
+        "cinematic",
+        "cinematicExtended",
+        "previewOptimized",
+        "cinematicExtendedEnhanced",
+        "auto",
+        "lowLatency"
+    );
 
     public String getVideoQualitySetting() {
         if (sessionConfig == null) {
@@ -4864,4 +4875,86 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         }
         return false;
     }
+
+    public boolean isVideoStabilizationSupported() {
+        return isStandardVideoStabilizationSupported();
+    }
+
+    public List<String> getSupportedVideoStabilizationModes() {
+        List<String> modes = new ArrayList<>();
+        modes.add("off");
+        if (isStandardVideoStabilizationSupported()) {
+            modes.add("standard");
+        }
+        return modes;
+    }
+
+    public String getVideoStabilizationModeSetting() {
+        if (sessionConfig == null) {
+            return "off";
+        }
+        return sessionConfig.getVideoStabilizationMode();
+    }
+
+    public void setVideoStabilizationModeSetting(String mode) {
+        if (sessionConfig == null) {
+            throw new IllegalStateException("Camera session is not running");
+        }
+        if (currentRecording != null) {
+            throw new IllegalStateException("Cannot change video stabilization while recording is in progress");
+        }
+        String normalized = mode != null ? mode : "off";
+        if (IOS_ONLY_VIDEO_STABILIZATION_MODES.contains(normalized)) {
+            throw new IllegalArgumentException(
+                "Video stabilization mode '" + normalized + "' is only supported on iOS. Use 'off' or 'standard' on Android."
+            );
+        }
+        if (!ALL_VIDEO_STABILIZATION_MODES.contains(normalized)) {
+            throw new IllegalArgumentException("Unsupported video stabilization mode: " + mode);
+        }
+        if ("standard".equals(normalized) && !isStandardVideoStabilizationSupported()) {
+            throw new IllegalArgumentException("Video stabilization mode 'standard' is not supported on this device");
+        }
+        if (normalized.equals(sessionConfig.getVideoStabilizationMode())) {
+            return;
+        }
+        sessionConfig.setVideoStabilizationMode(normalized);
+        if (sessionConfig.isVideoModeEnabled() && isRunning) {
+            mainExecutor.execute(this::bindCameraUseCases);
+        }
+    }
+
+    private boolean isVideoStabilizationEnabledForSession() {
+        if (sessionConfig == null) {
+            return false;
+        }
+        return "standard".equalsIgnoreCase(sessionConfig.getVideoStabilizationMode());
+    }
+
+    private boolean isStandardVideoStabilizationSupported() {
+        if (camera == null) {
+            return false;
+        }
+        try {
+            String cameraId = Camera2CameraInfo.from(camera.getCameraInfo()).getCameraId();
+            CameraManager cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
+            if (cameraManager == null) {
+                return false;
+            }
+            int[] modes = cameraManager
+                .getCameraCharacteristics(cameraId)
+                .get(CameraCharacteristics.CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
+            if (modes == null) {
+                return false;
+            }
+            for (int availableMode : modes) {
+                if (availableMode == CaptureRequest.CONTROL_VIDEO_STABILIZATION_MODE_ON) {
+                    return true;
+                }
+            }
+        } catch (CameraAccessException e) {
+            Log.w(TAG, "Failed to read video stabilization modes", e);
+        }
+        return false;
+    }
 }

package/android/src/main/java/app/capgo/capacitor/camera/preview/model/CameraSessionConfiguration.java

@@ -27,6 +27,7 @@ public class CameraSessionConfiguration {
     private boolean isCentered = false;
     private String videoQuality;
     private String videoCodec = "avc1";
+    private String videoStabilizationMode = "off";
     private boolean enablePhysicalDeviceSelection = false;
     private boolean barcodeScannerEnabled = false;
 
@@ -160,6 +161,14 @@ public class CameraSessionConfiguration {
         this.videoCodec = codec != null ? codec : "avc1";
     }
 
+    public String getVideoStabilizationMode() {
+        return videoStabilizationMode;
+    }
+
+    public void setVideoStabilizationMode(String mode) {
+        this.videoStabilizationMode = mode != null ? mode : "off";
+    }
+
     public boolean isPhysicalDeviceSelectionEnabled() {
         return enablePhysicalDeviceSelection;
     }

package/dist/docs.json

@@ -520,7 +520,7 @@
         "parameters": [
           {
             "name": "options",
-            "docs": "- The options for video recording.",
+            "docs": "- The options for video recording. Supports `videoCodec`, `videoStabilizationMode`, `maxDuration`, `maxFileSize`, and `disableAudio`.",
             "type": "CameraPreviewOptions"
           }
         ],
@@ -528,7 +528,7 @@
         "tags": [
           {
             "name": "param",
-            "text": "options - The options for video recording."
+            "text": "options - The options for video recording. Supports `videoCodec`, `videoStabilizationMode`, `maxDuration`, `maxFileSize`, and `disableAudio`."
           },
           {
             "name": "returns",
@@ -715,6 +715,114 @@
         ],
         "slug": "getsupportedvideocodecs"
       },
+      {
+        "name": "isVideoStabilizationSupported",
+        "signature": "() => Promise<{ supported: boolean; }>",
+        "parameters": [],
+        "returns": "Promise<{ supported: boolean; }>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "A promise that resolves with the support state."
+          },
+          {
+            "name": "since",
+            "text": "8.5.2"
+          },
+          {
+            "name": "platform",
+            "text": "android, ios"
+          }
+        ],
+        "docs": "Checks whether video stabilization is supported by the active camera.",
+        "complexTypes": [],
+        "slug": "isvideostabilizationsupported"
+      },
+      {
+        "name": "getSupportedVideoStabilizationModes",
+        "signature": "() => Promise<{ modes: VideoStabilizationMode[]; }>",
+        "parameters": [],
+        "returns": "Promise<{ modes: VideoStabilizationMode[]; }>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "A promise that resolves with supported modes."
+          },
+          {
+            "name": "since",
+            "text": "8.5.2"
+          },
+          {
+            "name": "platform",
+            "text": "android, ios"
+          }
+        ],
+        "docs": "Returns the video stabilization modes supported by the active camera.",
+        "complexTypes": [
+          "VideoStabilizationMode"
+        ],
+        "slug": "getsupportedvideostabilizationmodes"
+      },
+      {
+        "name": "getVideoStabilizationMode",
+        "signature": "() => Promise<{ mode: VideoStabilizationMode; }>",
+        "parameters": [],
+        "returns": "Promise<{ mode: VideoStabilizationMode; }>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "A promise that resolves with the current mode."
+          },
+          {
+            "name": "since",
+            "text": "8.5.2"
+          },
+          {
+            "name": "platform",
+            "text": "android, ios"
+          }
+        ],
+        "docs": "Gets the current video stabilization mode.",
+        "complexTypes": [
+          "VideoStabilizationMode"
+        ],
+        "slug": "getvideostabilizationmode"
+      },
+      {
+        "name": "setVideoStabilizationMode",
+        "signature": "(options: { mode: VideoStabilizationMode; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "- The desired stabilization mode.",
+            "type": "{ mode: VideoStabilizationMode; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "options - The desired stabilization mode."
+          },
+          {
+            "name": "returns",
+            "text": "A promise that resolves when the mode is set."
+          },
+          {
+            "name": "since",
+            "text": "8.5.2"
+          },
+          {
+            "name": "platform",
+            "text": "android, ios"
+          }
+        ],
+        "docs": "Sets the video stabilization mode for recording.\nCannot be changed while a recording is in progress.\nYou can also pass `videoStabilizationMode` in `startRecordVideo()` options.",
+        "complexTypes": [
+          "VideoStabilizationMode"
+        ],
+        "slug": "setvideostabilizationmode"
+      },
       {
         "name": "isRunning",
         "signature": "() => Promise<{ isRunning: boolean; }>",
@@ -1777,7 +1885,7 @@
               "name": "default"
             },
             {
-              "text": "android",
+              "text": "android, ios",
               "name": "platform"
             },
             {
@@ -1873,6 +1981,24 @@
           ],
           "type": "VideoCodec"
         },
+        {
+          "name": "videoStabilizationMode",
+          "tags": [
+            {
+              "text": "ios, android",
+              "name": "platform"
+            },
+            {
+              "text": "\"off\"",
+              "name": "default"
+            }
+          ],
+          "docs": "Preferred video stabilization mode for recording.",
+          "complexTypes": [
+            "VideoStabilizationMode"
+          ],
+          "type": "VideoStabilizationMode"
+        },
         {
           "name": "barcodeScanner",
           "tags": [
@@ -2713,6 +2839,45 @@
         }
       ]
     },
+    {
+      "name": "VideoStabilizationMode",
+      "slug": "videostabilizationmode",
+      "docs": "Video stabilization modes used when recording.\n\nOn Android only `off` and `standard` are supported.\nOn iOS all listed modes may be available when the device supports video stabilization.",
+      "types": [
+        {
+          "text": "'off'",
+          "complexTypes": []
+        },
+        {
+          "text": "'standard'",
+          "complexTypes": []
+        },
+        {
+          "text": "'cinematic'",
+          "complexTypes": []
+        },
+        {
+          "text": "'cinematicExtended'",
+          "complexTypes": []
+        },
+        {
+          "text": "'previewOptimized'",
+          "complexTypes": []
+        },
+        {
+          "text": "'cinematicExtendedEnhanced'",
+          "complexTypes": []
+        },
+        {
+          "text": "'auto'",
+          "complexTypes": []
+        },
+        {
+          "text": "'lowLatency'",
+          "complexTypes": []
+        }
+      ]
+    },
     {
       "name": "BarcodeScannerFormat",
       "slug": "barcodescannerformat",

package/dist/esm/definitions.d.ts

@@ -114,6 +114,13 @@ export type VideoQuality = 'low' | 'medium' | 'high' | '2160p' | '1080p' | '720p
  * - `hvc1`: HEVC / H.265
  */
 export type VideoCodec = 'avc1' | 'hvc1' | 'jpeg' | 'apcn' | 'ap4h';
+/**
+ * Video stabilization modes used when recording.
+ *
+ * On Android only `off` and `standard` are supported.
+ * On iOS all listed modes may be available when the device supports video stabilization.
+ */
+export type VideoStabilizationMode = 'off' | 'standard' | 'cinematic' | 'cinematicExtended' | 'previewOptimized' | 'cinematicExtendedEnhanced' | 'auto' | 'lowLatency';
 export type RecordingFinishedReason = 'manual' | 'maxDuration' | 'maxFileSize';
 export interface RecordingFinishedEvent {
     /**
@@ -274,7 +281,7 @@ export interface CameraPreviewOptions {
     /**
      * If true, enables video capture capabilities when the camera starts.
      * @default false
-     * @platform android
+     * @platform android, ios
      * @since 7.11.0
      */
     enableVideoMode?: boolean;
@@ -310,6 +317,12 @@ export interface CameraPreviewOptions {
      * @default "avc1"
      */
     videoCodec?: VideoCodec;
+    /**
+     * Preferred video stabilization mode for recording.
+     * @platform ios, android
+     * @default "off"
+     */
+    videoStabilizationMode?: VideoStabilizationMode;
     /**
      * Starts barcode scanning together with the camera preview.
      * Set to `true` or pass options to scan all supported formats.
@@ -658,7 +671,7 @@ export interface CameraPreviewPlugin {
     /**
      * Starts recording a video.
      *
-     * @param {CameraPreviewOptions} options - The options for video recording.
+     * @param {CameraPreviewOptions} options - The options for video recording. Supports `videoCodec`, `videoStabilizationMode`, `maxDuration`, `maxFileSize`, and `disableAudio`.
      * @returns {Promise<void>} A promise that resolves when video recording starts.
      * @since 0.0.1
      */
@@ -725,6 +738,49 @@ export interface CameraPreviewPlugin {
     getSupportedVideoCodecs(): Promise<{
         codecs: VideoCodec[];
     }>;
+    /**
+     * Checks whether video stabilization is supported by the active camera.
+     *
+     * @returns {Promise<{ supported: boolean }>} A promise that resolves with the support state.
+     * @since 8.5.2
+     * @platform android, ios
+     */
+    isVideoStabilizationSupported(): Promise<{
+        supported: boolean;
+    }>;
+    /**
+     * Returns the video stabilization modes supported by the active camera.
+     *
+     * @returns {Promise<{ modes: VideoStabilizationMode[] }>} A promise that resolves with supported modes.
+     * @since 8.5.2
+     * @platform android, ios
+     */
+    getSupportedVideoStabilizationModes(): Promise<{
+        modes: VideoStabilizationMode[];
+    }>;
+    /**
+     * Gets the current video stabilization mode.
+     *
+     * @returns {Promise<{ mode: VideoStabilizationMode }>} A promise that resolves with the current mode.
+     * @since 8.5.2
+     * @platform android, ios
+     */
+    getVideoStabilizationMode(): Promise<{
+        mode: VideoStabilizationMode;
+    }>;
+    /**
+     * Sets the video stabilization mode for recording.
+     * Cannot be changed while a recording is in progress.
+     * You can also pass `videoStabilizationMode` in `startRecordVideo()` options.
+     *
+     * @param {{ mode: VideoStabilizationMode }} options - The desired stabilization mode.
+     * @returns {Promise<void>} A promise that resolves when the mode is set.
+     * @since 8.5.2
+     * @platform android, ios
+     */
+    setVideoStabilizationMode(options: {
+        mode: VideoStabilizationMode;
+    }): Promise<void>;
     /**
      * Checks if the camera preview is currently running.
      *