@luciq/react-native 19.0.0 → 19.1.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [19.1.0](https://github.com/luciqai/luciq-reactnative-sdk/compare/v19.1.0...19.0.0)
+
+### Added
+
+- Add support session replay Video-Like. ([#19](https://github.com/luciqai/luciq-reactnative-sdk/pull/19))
+
+### Changed
+
+- Bump Luciq iOS SDK to v19.3.0 ([#22](https://github.com/luciqai/luciq-reactnative-sdk/pull/22)). [See release notes](https://github.com/luciqai/Luciq-iOS-sdk/releases/tag/19.3.0).
+
+- Bump Luciq Android SDK to v19.1.0 ([#22](https://github.com/luciqai/luciq-reactnative-sdk/pull/22)). [See release notes](https://github.com/luciqai/Luciq-Android-sdk/releases/tag/v19.1.0).
+
 ## [19.0.0](https://github.com/luciqai/luciq-reactnative-sdk/compare/v19.0.0...dev)
 
 ### Added
@@ -44,4 +56,4 @@
 
 ## [18.0.0](https://github.com/luciqai/luciq-reactnative-sdk/compare/v18.0.0...dev) (September 24, 2025)
 
-- SDK rebranded from Luciq to Luciq.
+- SDK rebranded from Instabug to Luciq.

package/android/native.gradle

@@ -1,5 +1,5 @@
 project.ext.luciq = [
-    version: '19.0.0'
+    version: '19.1.0'
 ]
 
 dependencies {

package/android/src/main/java/ai/luciq/reactlibrary/ArgsRegistry.java

@@ -65,6 +65,8 @@ final class ArgsRegistry {
             putAll(overAirUpdateService);
             putAll(autoMaskingTypes);
             putAll(userConsentActionType);
+            putAll(capturingModes);
+            putAll(screenshotQualities);
         }};
     }
 
@@ -275,4 +277,16 @@ final class ArgsRegistry {
         put("media", MaskingType.MEDIA);
         put("none", MaskingType.MASK_NOTHING);
     }};
+
+    public static final ArgsMap<Integer> capturingModes = new ArgsMap<Integer>() {{
+        put("capturingModeNavigation", ai.luciq.library.sessionreplay.CapturingMode.NAVIGATION);
+        put("capturingModeInteractions", ai.luciq.library.sessionreplay.CapturingMode.INTERACTIONS);
+        put("capturingModeFrequency", ai.luciq.library.sessionreplay.CapturingMode.FREQUENCY);
+    }};
+
+    public static final ArgsMap<Integer> screenshotQualities = new ArgsMap<Integer>() {{
+        put("screenshotQualityHigh", ai.luciq.library.sessionreplay.ScreenshotQuality.HIGH);
+        put("screenshotQualityNormal", ai.luciq.library.sessionreplay.ScreenshotQuality.NORMAL);
+        put("screenshotQualityGreyscale", ai.luciq.library.sessionreplay.ScreenshotQuality.GREYSCALE);
+    }};
 }

package/android/src/main/java/ai/luciq/reactlibrary/RNLuciqSessionReplayModule.java

@@ -18,6 +18,7 @@ import ai.luciq.library.sessionreplay.SessionReplay;
 import ai.luciq.library.sessionreplay.model.SessionMetadata;
 import ai.luciq.reactlibrary.utils.EventEmitterModule;
 import ai.luciq.reactlibrary.utils.MainThreadHandler;
+import android.util.Log;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
@@ -208,6 +209,56 @@ public class RNLuciqSessionReplayModule extends EventEmitterModule {
         }
     }
 
+    @ReactMethod
+    public void setCapturingMode(final String mode) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Integer capturingMode = ArgsRegistry.capturingModes.get(mode);
+                    if (capturingMode != null) {
+                        SessionReplay.setCapturingMode(capturingMode);
+                    } else {
+                        Log.w("LCQSessionReplay", "Invalid capturing mode: " + mode);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void setScreenshotQuality(final String quality) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Integer screenshotQuality = ArgsRegistry.screenshotQualities.get(quality);
+                    if (screenshotQuality != null) {
+                        SessionReplay.setScreenshotQuality(screenshotQuality);
+                    } else {
+                        Log.w("LCQSessionReplay", "Invalid screenshot quality: " + quality);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
 
+    @ReactMethod
+    public void setScreenshotCaptureInterval(final int intervalMs) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    SessionReplay.setScreenshotCaptureInterval(intervalMs);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
 
 }

package/dist/modules/SessionReplay.d.ts

@@ -1,4 +1,5 @@
 import type { SessionMetadata } from '../models/SessionMetadata';
+import type { CapturingMode, ScreenshotQuality } from '../utils/Enums';
 /**
  * Enables or disables Session Replay for your Luciq integration.
  *
@@ -76,3 +77,56 @@ export declare const getSessionReplayLink: () => Promise<string>;
  * ```
  */
 export declare const setSyncCallback: (handler: (payload: SessionMetadata) => boolean) => Promise<void>;
+/**
+ * Sets the capturing mode for Session Replay screenshots.
+ *
+ * - `navigation`: Captures screenshots only when users navigate between screens (default).
+ * - `interactions`: Captures screenshots on screen navigation and user interactions.
+ * - `frequency`: Captures screenshots at a fixed time interval for video-like playback.
+ *
+ * Note: Should be called before SDK initialization for best results.
+ *
+ * @param mode The capturing mode to use.
+ *
+ * @example
+ * ```ts
+ * import { CapturingMode } from '@luciq/react-native';
+ *
+ * SessionReplay.setCapturingMode(CapturingMode.frequency);
+ * ```
+ */
+export declare const setCapturingMode: (mode: CapturingMode) => void;
+/**
+ * Sets the visual quality of captured Session Replay screenshots.
+ *
+ * - `high`: 50% WebP compression - Best visual quality (~62 screenshots per session).
+ * - `normal`: 25% WebP compression - Balanced quality and storage (~104 screenshots per session, default).
+ * - `greyscale`: Grayscale + 25% WebP compression - Maximum storage efficiency (~130 screenshots per session).
+ *
+ * @param quality The screenshot quality profile to use.
+ *
+ * @example
+ * ```ts
+ * import { ScreenshotQuality } from '@luciq/react-native';
+ *
+ * SessionReplay.setScreenshotQuality(ScreenshotQuality.high);
+ * ```
+ */
+export declare const setScreenshotQuality: (quality: ScreenshotQuality) => void;
+/**
+ * Sets the capture interval for Session Replay when using frequency capturing mode.
+ *
+ * This determines how often screenshots are captured when `CapturingMode.frequency` is set.
+ *
+ * @param intervalMs Time between captures in milliseconds. Minimum: 500ms, Default: 1000ms.
+ *
+ * @example
+ * ```ts
+ * // Capture every 500ms (2 FPS)
+ * SessionReplay.setScreenshotCaptureInterval(500);
+ *
+ * // Capture every 2 seconds
+ * SessionReplay.setScreenshotCaptureInterval(2000);
+ * ```
+ */
+export declare const setScreenshotCaptureInterval: (intervalMs: number) => void;

package/dist/modules/SessionReplay.js

@@ -96,3 +96,62 @@ export const setSyncCallback = async (handler) => {
     });
     return NativeSessionReplay.setSyncCallback();
 };
+/**
+ * Sets the capturing mode for Session Replay screenshots.
+ *
+ * - `navigation`: Captures screenshots only when users navigate between screens (default).
+ * - `interactions`: Captures screenshots on screen navigation and user interactions.
+ * - `frequency`: Captures screenshots at a fixed time interval for video-like playback.
+ *
+ * Note: Should be called before SDK initialization for best results.
+ *
+ * @param mode The capturing mode to use.
+ *
+ * @example
+ * ```ts
+ * import { CapturingMode } from '@luciq/react-native';
+ *
+ * SessionReplay.setCapturingMode(CapturingMode.frequency);
+ * ```
+ */
+export const setCapturingMode = (mode) => {
+    NativeSessionReplay.setCapturingMode(mode);
+};
+/**
+ * Sets the visual quality of captured Session Replay screenshots.
+ *
+ * - `high`: 50% WebP compression - Best visual quality (~62 screenshots per session).
+ * - `normal`: 25% WebP compression - Balanced quality and storage (~104 screenshots per session, default).
+ * - `greyscale`: Grayscale + 25% WebP compression - Maximum storage efficiency (~130 screenshots per session).
+ *
+ * @param quality The screenshot quality profile to use.
+ *
+ * @example
+ * ```ts
+ * import { ScreenshotQuality } from '@luciq/react-native';
+ *
+ * SessionReplay.setScreenshotQuality(ScreenshotQuality.high);
+ * ```
+ */
+export const setScreenshotQuality = (quality) => {
+    NativeSessionReplay.setScreenshotQuality(quality);
+};
+/**
+ * Sets the capture interval for Session Replay when using frequency capturing mode.
+ *
+ * This determines how often screenshots are captured when `CapturingMode.frequency` is set.
+ *
+ * @param intervalMs Time between captures in milliseconds. Minimum: 500ms, Default: 1000ms.
+ *
+ * @example
+ * ```ts
+ * // Capture every 500ms (2 FPS)
+ * SessionReplay.setScreenshotCaptureInterval(500);
+ *
+ * // Capture every 2 seconds
+ * SessionReplay.setScreenshotCaptureInterval(2000);
+ * ```
+ */
+export const setScreenshotCaptureInterval = (intervalMs) => {
+    NativeSessionReplay.setScreenshotCaptureInterval(intervalMs);
+};

package/dist/native/NativeConstants.d.ts

@@ -1,4 +1,4 @@
-export type NativeConstants = NativeSdkDebugLogsLevel & NativeInvocationEvent & NativeInvocationOption & NativeColorTheme & NativeFloatingButtonPosition & NativeRecordingButtonPosition & NativeWelcomeMessageMode & NativeReportType & NativeDismissType & NativeActionType & NativeExtendedBugReportMode & NativeReproStepsMode & NativeLocale & NativeNonFatalErrorLevel & NativeStringKey & NativeLaunchType & NativeOverAirUpdateServices & NativeAutoMaskingType & NativeUserConsentActionType;
+export type NativeConstants = NativeSdkDebugLogsLevel & NativeInvocationEvent & NativeInvocationOption & NativeColorTheme & NativeFloatingButtonPosition & NativeRecordingButtonPosition & NativeWelcomeMessageMode & NativeReportType & NativeDismissType & NativeActionType & NativeExtendedBugReportMode & NativeReproStepsMode & NativeLocale & NativeNonFatalErrorLevel & NativeStringKey & NativeLaunchType & NativeOverAirUpdateServices & NativeAutoMaskingType & NativeUserConsentActionType & NativeCapturingMode & NativeScreenshotQuality;
 interface NativeSdkDebugLogsLevel {
     sdkDebugLogsLevelVerbose: any;
     sdkDebugLogsLevelDebug: any;
@@ -179,4 +179,14 @@ interface NativeAutoMaskingType {
     media: any;
     none: any;
 }
+interface NativeCapturingMode {
+    capturingModeNavigation: any;
+    capturingModeInteractions: any;
+    capturingModeFrequency: any;
+}
+interface NativeScreenshotQuality {
+    screenshotQualityHigh: any;
+    screenshotQualityNormal: any;
+    screenshotQualityGreyscale: any;
+}
 export {};

package/dist/native/NativeSessionReplay.d.ts

@@ -8,6 +8,9 @@ export interface SessionReplayNativeModule extends NativeModule {
     getSessionReplayLink(): Promise<string>;
     setSyncCallback(): Promise<void>;
     evaluateSync(shouldSync: boolean): void;
+    setCapturingMode(mode: any): void;
+    setScreenshotQuality(quality: any): void;
+    setScreenshotCaptureInterval(intervalMs: number): void;
 }
 export declare const NativeSessionReplay: SessionReplayNativeModule;
 export declare enum NativeEvents {

package/dist/utils/Enums.d.ts

@@ -242,3 +242,40 @@ export declare enum AutoMaskingType {
     media,
     none
 }
+/**
+ * The capturing mode for Session Replay screenshots.
+ */
+export declare enum CapturingMode {
+    /**
+     * Captures screenshots only when users navigate between screens.
+     * This is the default behavior and provides the lowest overhead.
+     */
+    navigation,
+    /**
+     * Captures screenshots on screen navigation and user interactions.
+     * Includes debouncing to prevent excessive captures.
+     */
+    interactions,
+    /**
+     * Captures screenshots at a fixed time interval for true video-like playback.
+     * Also captures on screen navigation.
+     */
+    frequency
+}
+/**
+ * The quality profile for Session Replay screenshots.
+ */
+export declare enum ScreenshotQuality {
+    /**
+     * 50% WebP compression - Best visual quality.
+     */
+    high,
+    /**
+     * 25% WebP compression - Balanced quality and storage (default).
+     */
+    normal,
+    /**
+     * Grayscale + 25% WebP compression - Maximum storage efficiency.
+     */
+    greyscale
+}

package/dist/utils/Enums.js

@@ -264,3 +264,42 @@ export var AutoMaskingType;
     AutoMaskingType[AutoMaskingType["media"] = constants.media] = "media";
     AutoMaskingType[AutoMaskingType["none"] = constants.none] = "none";
 })(AutoMaskingType || (AutoMaskingType = {}));
+/**
+ * The capturing mode for Session Replay screenshots.
+ */
+export var CapturingMode;
+(function (CapturingMode) {
+    /**
+     * Captures screenshots only when users navigate between screens.
+     * This is the default behavior and provides the lowest overhead.
+     */
+    CapturingMode[CapturingMode["navigation"] = constants.capturingModeNavigation] = "navigation";
+    /**
+     * Captures screenshots on screen navigation and user interactions.
+     * Includes debouncing to prevent excessive captures.
+     */
+    CapturingMode[CapturingMode["interactions"] = constants.capturingModeInteractions] = "interactions";
+    /**
+     * Captures screenshots at a fixed time interval for true video-like playback.
+     * Also captures on screen navigation.
+     */
+    CapturingMode[CapturingMode["frequency"] = constants.capturingModeFrequency] = "frequency";
+})(CapturingMode || (CapturingMode = {}));
+/**
+ * The quality profile for Session Replay screenshots.
+ */
+export var ScreenshotQuality;
+(function (ScreenshotQuality) {
+    /**
+     * 50% WebP compression - Best visual quality.
+     */
+    ScreenshotQuality[ScreenshotQuality["high"] = constants.screenshotQualityHigh] = "high";
+    /**
+     * 25% WebP compression - Balanced quality and storage (default).
+     */
+    ScreenshotQuality[ScreenshotQuality["normal"] = constants.screenshotQualityNormal] = "normal";
+    /**
+     * Grayscale + 25% WebP compression - Maximum storage efficiency.
+     */
+    ScreenshotQuality[ScreenshotQuality["greyscale"] = constants.screenshotQualityGreyscale] = "greyscale";
+})(ScreenshotQuality || (ScreenshotQuality = {}));

package/ios/RNLuciq/ArgsRegistry.h

@@ -28,5 +28,7 @@ typedef NSDictionary<NSString*, NSNumber*> ArgsDictionary;
 
 + (NSDictionary<NSString *, NSString *> *) placeholders;
 + (ArgsDictionary *)autoMaskingTypes;
++ (ArgsDictionary *)capturingModes;
++ (ArgsDictionary *)screenshotQualities;
 
 @end

package/ios/RNLuciq/ArgsRegistry.m

@@ -25,6 +25,8 @@
 
     [all addEntriesFromDictionary:ArgsRegistry.autoMaskingTypes];
     [all addEntriesFromDictionary:ArgsRegistry.userConsentActionTypes];
+    [all addEntriesFromDictionary:ArgsRegistry.capturingModes];
+    [all addEntriesFromDictionary:ArgsRegistry.screenshotQualities];
 
     return all;
 }
@@ -273,4 +275,20 @@
         @"none" : @(LCQAutoMaskScreenshotOptionMaskNothing)
     };
 }
+
++ (ArgsDictionary *)capturingModes {
+    return @{
+        @"capturingModeNavigation" : @(LCQScreenshotCapturingModeNavigation),
+        @"capturingModeInteractions" : @(LCQScreenshotCapturingModeInteraction),
+        @"capturingModeFrequency" : @(LCQScreenshotCapturingModeFrequency)
+    };
+}
+
++ (ArgsDictionary *)screenshotQualities {
+    return @{
+        @"screenshotQualityHigh" : @(LCQScreenshotQualityModeHigh),
+        @"screenshotQualityNormal" : @(LCQScreenshotQualityModeNormal),
+        @"screenshotQualityGreyscale" : @(LCQScreenshotQualityModeGreyScale)
+    };
+}
 @end

package/ios/RNLuciq/LuciqSessionReplayBridge.h

@@ -25,6 +25,12 @@
 
 - (void)evaluateSync:(BOOL)result;
 
+- (void)setCapturingMode:(LCQScreenshotCapturingMode)mode;
+
+- (void)setScreenshotQuality:(LCQScreenshotQualityMode)quality;
+
+- (void)setScreenshotCaptureInterval:(NSInteger)intervalMs;
+
 @property (atomic, copy) SessionEvaluationCompletion sessionEvaluationCompletion;
 
 @end

package/ios/RNLuciq/LuciqSessionReplayBridge.m

@@ -95,6 +95,17 @@ RCT_EXPORT_METHOD(evaluateSync:(BOOL)result) {
     }
 }
 
+RCT_EXPORT_METHOD(setCapturingMode:(LCQScreenshotCapturingMode)mode) {
+    LCQSessionReplay.screenshotCapturingMode = mode;
+}
+
+RCT_EXPORT_METHOD(setScreenshotQuality:(LCQScreenshotQualityMode)quality) {
+    LCQSessionReplay.screenshotQualityMode = quality;
+}
+
+RCT_EXPORT_METHOD(setScreenshotCaptureInterval:(NSInteger)intervalMs) {
+    LCQSessionReplay.screenshotCaptureInterval = intervalMs;
+}
 
 @synthesize description;
 

package/ios/RNLuciq/RCTConvert+LuciqEnums.m

@@ -123,5 +123,19 @@ RCT_ENUM_CONVERTER(
   integerValue
 );
 
+RCT_ENUM_CONVERTER(
+  LCQScreenshotCapturingMode,
+  ArgsRegistry.capturingModes,
+  LCQScreenshotCapturingModeNavigation,
+  integerValue
+);
+
+RCT_ENUM_CONVERTER(
+  LCQScreenshotQualityMode,
+  ArgsRegistry.screenshotQualities,
+  LCQScreenshotQualityModeNormal,
+  integerValue
+);
+
 @end
 

package/ios/native.rb

@@ -1,4 +1,4 @@
-$luciq= { :version => '19.2.0' }
+$luciq= { :version => '19.3.0' }
 
 def use_luciq! (spec = nil)
   version = $luciq[:version]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@luciq/react-native",
   "description": "Luciq is the Agentic Observability Platform built for Mobile.",
-  "version": "19.0.0",
+  "version": "19.1.0",
   "author": "Luciq (https://luciq.ai)",
   "repository": "github:luciqai/luciq-reactnative-sdk",
   "homepage": "https://www.luciq.ai/platforms/react-native",

package/src/modules/SessionReplay.ts

@@ -1,5 +1,6 @@
 import { NativeSessionReplay, NativeEvents, emitter } from '../native/NativeSessionReplay';
 import type { SessionMetadata } from '../models/SessionMetadata';
+import type { CapturingMode, ScreenshotQuality } from '../utils/Enums';
 /**
  * Enables or disables Session Replay for your Luciq integration.
  *
@@ -109,3 +110,65 @@ export const setSyncCallback = async (
 
   return NativeSessionReplay.setSyncCallback();
 };
+
+/**
+ * Sets the capturing mode for Session Replay screenshots.
+ *
+ * - `navigation`: Captures screenshots only when users navigate between screens (default).
+ * - `interactions`: Captures screenshots on screen navigation and user interactions.
+ * - `frequency`: Captures screenshots at a fixed time interval for video-like playback.
+ *
+ * Note: Should be called before SDK initialization for best results.
+ *
+ * @param mode The capturing mode to use.
+ *
+ * @example
+ * ```ts
+ * import { CapturingMode } from '@luciq/react-native';
+ *
+ * SessionReplay.setCapturingMode(CapturingMode.frequency);
+ * ```
+ */
+export const setCapturingMode = (mode: CapturingMode) => {
+  NativeSessionReplay.setCapturingMode(mode);
+};
+
+/**
+ * Sets the visual quality of captured Session Replay screenshots.
+ *
+ * - `high`: 50% WebP compression - Best visual quality (~62 screenshots per session).
+ * - `normal`: 25% WebP compression - Balanced quality and storage (~104 screenshots per session, default).
+ * - `greyscale`: Grayscale + 25% WebP compression - Maximum storage efficiency (~130 screenshots per session).
+ *
+ * @param quality The screenshot quality profile to use.
+ *
+ * @example
+ * ```ts
+ * import { ScreenshotQuality } from '@luciq/react-native';
+ *
+ * SessionReplay.setScreenshotQuality(ScreenshotQuality.high);
+ * ```
+ */
+export const setScreenshotQuality = (quality: ScreenshotQuality) => {
+  NativeSessionReplay.setScreenshotQuality(quality);
+};
+
+/**
+ * Sets the capture interval for Session Replay when using frequency capturing mode.
+ *
+ * This determines how often screenshots are captured when `CapturingMode.frequency` is set.
+ *
+ * @param intervalMs Time between captures in milliseconds. Minimum: 500ms, Default: 1000ms.
+ *
+ * @example
+ * ```ts
+ * // Capture every 500ms (2 FPS)
+ * SessionReplay.setScreenshotCaptureInterval(500);
+ *
+ * // Capture every 2 seconds
+ * SessionReplay.setScreenshotCaptureInterval(2000);
+ * ```
+ */
+export const setScreenshotCaptureInterval = (intervalMs: number) => {
+  NativeSessionReplay.setScreenshotCaptureInterval(intervalMs);
+};

package/src/native/NativeConstants.ts

@@ -16,7 +16,9 @@ export type NativeConstants = NativeSdkDebugLogsLevel &
   NativeLaunchType &
   NativeOverAirUpdateServices &
   NativeAutoMaskingType &
-  NativeUserConsentActionType;
+  NativeUserConsentActionType &
+  NativeCapturingMode &
+  NativeScreenshotQuality;
 
 interface NativeSdkDebugLogsLevel {
   sdkDebugLogsLevelVerbose: any;
@@ -213,3 +215,15 @@ interface NativeAutoMaskingType {
   media: any;
   none: any;
 }
+
+interface NativeCapturingMode {
+  capturingModeNavigation: any;
+  capturingModeInteractions: any;
+  capturingModeFrequency: any;
+}
+
+interface NativeScreenshotQuality {
+  screenshotQualityHigh: any;
+  screenshotQualityNormal: any;
+  screenshotQualityGreyscale: any;
+}

package/src/native/NativeSessionReplay.ts

@@ -11,6 +11,9 @@ export interface SessionReplayNativeModule extends NativeModule {
   getSessionReplayLink(): Promise<string>;
   setSyncCallback(): Promise<void>;
   evaluateSync(shouldSync: boolean): void;
+  setCapturingMode(mode: any): void;
+  setScreenshotQuality(quality: any): void;
+  setScreenshotCaptureInterval(intervalMs: number): void;
 }
 
 export const NativeSessionReplay = NativeModules.LCQSessionReplay;

package/src/utils/Enums.ts

@@ -264,3 +264,42 @@ export enum AutoMaskingType {
   media = constants.media,
   none = constants.none,
 }
+
+/**
+ * The capturing mode for Session Replay screenshots.
+ */
+export enum CapturingMode {
+  /**
+   * Captures screenshots only when users navigate between screens.
+   * This is the default behavior and provides the lowest overhead.
+   */
+  navigation = constants.capturingModeNavigation,
+  /**
+   * Captures screenshots on screen navigation and user interactions.
+   * Includes debouncing to prevent excessive captures.
+   */
+  interactions = constants.capturingModeInteractions,
+  /**
+   * Captures screenshots at a fixed time interval for true video-like playback.
+   * Also captures on screen navigation.
+   */
+  frequency = constants.capturingModeFrequency,
+}
+
+/**
+ * The quality profile for Session Replay screenshots.
+ */
+export enum ScreenshotQuality {
+  /**
+   * 50% WebP compression - Best visual quality.
+   */
+  high = constants.screenshotQualityHigh,
+  /**
+   * 25% WebP compression - Balanced quality and storage (default).
+   */
+  normal = constants.screenshotQualityNormal,
+  /**
+   * Grayscale + 25% WebP compression - Maximum storage efficiency.
+   */
+  greyscale = constants.screenshotQualityGreyscale,
+}