@ansight/react-native 1.3.0-preview.1 → 1.3.0-preview.11

package/README.md

@@ -77,8 +77,8 @@ bundle; its API requires the native Ansight module.
 
 This package version expects matching native SDK packages:
 
-- CocoaPods: `Ansight`, `AnsightObjC` version `1.3.0-preview.1`
-- Maven: `ai.ansight:ansight-android:1.3.0-preview.1`
+- CocoaPods: `Ansight`, `AnsightObjC` version `1.3.0-preview.11`
+- Maven: `ai.ansight:ansight-android:1.3.0-preview.11`
 
 ## Quickstart
 
@@ -136,10 +136,12 @@ The TypeScript `AnsightOptions` surface mirrors Android `AnsightOptions`, iOS
 | `retentionPeriodSeconds` | Local metric/event retention window. |
 | `enableFramesPerSecond` | Enables native FPS sampling. |
 | `enableBatteryLevel` | Enables battery sampling where available. |
+| `enableOpenFileHandleTracking` | Enables native process open-file-handle sampling. Disabled by default. |
+| `enableJniReferenceCountTracking` | Enables JNI reference-count tracking where the runtime can supply it. Disabled by default. |
 | `defaultMemoryChannels` | Selects built-in memory channels. Prefer `managedHeap`, `nativeHeap`, `residentSetSize`, and `physicalFootprint`; `javaHeap` and `rss` are accepted as Android/RN compatibility aliases. |
 | `reactNativeMemory` | Controls native React Native runtime memory channels. Enabled by default; set to `false` to disable, or use `{ jsHeapUsed, jsHeapTotal }`. |
 | `additionalChannels` | Registers custom metric channels. |
-| `sessionJpegCapture` | Object to enable/configure capture, or `false` to disable. Supports `captureGpuBackedSurfaces`; on iOS it defaults to `true` so Metal, SceneKit, and similar GPU-backed views are included. |
+| `sessionJpegCapture` | Object to enable/configure capture, or `false` to disable. `mode` accepts `screenshotOnly`, `screenshotAndVisualTree`, or `screenshotWithVisualTreeOnTouch`. Supports `captureGpuBackedSurfaces`; on iOS it defaults to `true` so Metal, SceneKit, and similar GPU-backed views are included. |
 | `touchCapture` | Object to enable/configure capture, or `false` to disable. |
 | `lifecycleCapture` | Native lifecycle and screen-view capture options. |
 | `toolGuard` | `"disabled"`, `"readOnly"`, `"readWrite"`, or `"fullAccess"`. |
@@ -149,6 +151,12 @@ The TypeScript `AnsightOptions` surface mirrors Android `AnsightOptions`, iOS
 | `secureStorage` | Compatibility alias for native secure-storage allow-list settings. |
 | `remoteTools` | Native visual tree, file, database, preferences, reflection, and secure-storage tool options. |
 | `lifecycle` | JS AppState tracking toggle. Defaults to true. |
+| `networkCapture` | Opt-in `fetch` and `XMLHttpRequest` metadata capture. Accepts `true` or sanitization/capture options. |
+
+Use `withOpenFileHandleTracking()` and `withJniReferenceCountTracking()` to
+opt in through the builder. Matching `without...` methods disable the channels
+again. Open handles are sampled by the native Android/iOS runtime. JNI counts
+are available on Android only when the host integration can supply them.
 
 Cellular host connections are disabled by default. The restriction applies to
 enrollment and reconnect requests. Opt in only for a trusted development host
@@ -175,6 +183,7 @@ await Ansight.initializeAndActivate({
     quality: 60,
     maxWidth: 480,
     captureGpuBackedSurfaces: true,
+    mode: "screenshotWithVisualTreeOnTouch",
   },
   touchCapture: {
     captureMoveEvents: true,
@@ -192,10 +201,50 @@ await Ansight.initializeAndActivate({
 });
 ```
 
+The touch mode captures native visual trees only on touch down and touch up.
+Move and cancel events do not trigger capture. Rapid boundaries are coalesced
+and rate-limited to protect screenshot cadence. Native touch capture and
+visual-tree tools/providers must remain enabled.
+
 On iOS, `captureGpuBackedSurfaces` defaults to `true` so Metal, SceneKit, and
 similar GPU-backed views are included. Set it to `false` to use a lower-overhead
 capture path when those surfaces are not needed.
 
+## Network capture
+
+Network capture is explicitly enabled by the React Native layer, which
+instruments `fetch` and `XMLHttpRequest`, then sends a typed metadata record
+through the native bridge. It is opt-in:
+
+```ts
+await Ansight.initializeAndActivate(
+  Ansight.createOptionsBuilder()
+    .withAnsightDefaults()
+    .withNetworkCapture({
+      maximumBodyBytes: 64 * 1024,
+      additionalSensitiveHeaderNames: ["x-tenant-secret"],
+      additionalSensitiveQueryParameterNames: ["session"],
+      requestSanitizer: request =>
+        request.url.includes("/health") ? null : request,
+    })
+    .withoutNetworkRequestBodies() // optional, independent opt-out
+    .build(),
+);
+```
+
+Text request and response bodies are included by default after network capture
+is explicitly enabled, with a 64 KiB default per-body limit. Set a larger
+`maximumBodyBytes` when needed; use the request/response body builder methods to
+opt either side out or back in, and `captureBinaryBodies` to explicitly allow
+Base64 binary content. Standard credentials, cloud signed-URL fields, cookies,
+URL user information, and sensitive text-body assignments are redacted before
+the bridge. Capture hooks detach whenever the native host is disconnected.
+
+Use `installNetworkCapture(...)` and `uninstallNetworkCapture()` when capture
+must be controlled independently of initialization. `recordNetworkRequest(...)`
+supports custom HTTP stacks, and `sanitizeNetworkRequest(...)` exposes the same
+app-side policy for inspection or testing.
+
 ## Native Tool Options
 
 `remoteTools` configures the native tool suites registered by the bridge. `useNativeAllInOneDefaults: true` enables visual tree tools by default so Studio can pair `ui.get_visual_tree` data with `ui.get_screenshot` frames. Apps that do not use all-in-one defaults can opt in explicitly:
@@ -377,6 +426,19 @@ await Ansight.clearSessionProperties();
 When connected, property mutations are sent immediately. When disconnected, the
 latest values are included in the next `session.open`.
 
+The bridge automatically adds these property groups:
+
+| Group | Properties |
+| --- | --- |
+| `reactNative` | Ansight SDK, React Native and React versions; platform and runtime language; JavaScript engine and available Hermes version/bytecode details; legacy/new architecture; bridgeless state; development mode. |
+| `localization` | Canonical locale, language, optional region, IANA time zone when exposed by `Intl`, and UTC offset in minutes. |
+
+App-provided values override an automatic value with the same group and key.
+Clearing all properties, or removing one automatic property, restores the
+current bridge-owned value. `localization` reflects the JavaScript runtime
+locale; if the app selects a different language through an i18n library, set
+`localization.locale`, `language`, and `region` explicitly.
+
 ## Tool Guards
 
 | Value | Allowed scopes |

package/android/build.gradle

@@ -67,6 +67,6 @@ repositories {
 dependencies {
   implementation("com.facebook.react:react-android")
   def ansightAndroidVersion =
-      findProperty("ansightAndroidVersion") ?: "1.3.0-preview.1"
-  implementation("ai.ansight:ansight-android:1.3.0-preview.1")
+      findProperty("ansightAndroidVersion") ?: "1.3.0-preview.11"
+  implementation("ai.ansight:ansight-android:1.3.0-preview.11")
 }

package/android/src/main/kotlin/ai/ansight/reactnative/AnsightReactNativeModule.kt

@@ -6,11 +6,13 @@ import ai.ansight.runtime.AndroidToolExecutionContext
 import ai.ansight.runtime.AndroidToolResult
 import ai.ansight.runtime.AnsightChannel
 import ai.ansight.runtime.AnsightChannels
+import ai.ansight.runtime.AnsightCrashCaptureOptions
 import ai.ansight.runtime.AnsightHostAutoProbeOptions
 import ai.ansight.runtime.AnsightHostConnectionOptions
 import ai.ansight.runtime.AnsightLogCallback
 import ai.ansight.runtime.AnsightLogLevel
 import ai.ansight.runtime.AnsightLogger
+import ai.ansight.runtime.AnsightNetworkRequest
 import ai.ansight.runtime.AnsightOptions
 import ai.ansight.runtime.AnsightOptionsBuilder
 import ai.ansight.runtime.AnsightRuntime
@@ -27,6 +29,7 @@ import ai.ansight.runtime.HostConnectionRequestKind
 import ai.ansight.runtime.HostConnectionCapabilities
 import ai.ansight.runtime.HostConnectionResult
 import ai.ansight.runtime.HostConnectionStatus
+import ai.ansight.runtime.HostConnectionStatusSubscription
 import ai.ansight.runtime.OperationResult
 import ai.ansight.runtime.OpenSessionResult
 import ai.ansight.runtime.PairingOpenOptions
@@ -103,16 +106,21 @@ class AnsightReactNativeModule(
     private val logCallback = AnsightLogCallback { level, message, throwable ->
         emitLogEvent(level, message, throwable)
     }
+    private val hostConnectionStatusSubscription: HostConnectionStatusSubscription
 
     init {
         reactContext.addLifecycleEventListener(this)
         AnsightLogger.registerCallback(logCallback)
+        hostConnectionStatusSubscription = AnsightRuntime.addHostConnectionStatusListener(
+            listener = { status, _ -> emitHostConnectionStatusEvent(status) },
+        )
     }
 
     override fun getName(): String = "AnsightReactNative"
 
     override fun invalidate() {
         AnsightLogger.removeCallback(logCallback)
+        hostConnectionStatusSubscription.remove()
         reactContext.removeLifecycleEventListener(this)
         super.invalidate()
     }
@@ -225,6 +233,32 @@ class AnsightReactNativeModule(
         }.resolve(promise)
     }
 
+    @ReactMethod
+    fun recordNetworkRequest(input: ReadableMap, promise: Promise) {
+        runCatching {
+            val request = AnsightNetworkRequest.fromJson(JSONObject(input.toHashMap()))
+                ?: return@runCatching operationResultMap(
+                    OperationResult.failure("Network request must use the ansight.network-request.v1 schema."),
+                )
+            operationResultMap(AnsightRuntime.recordNetworkRequest(request))
+        }.resolve(promise)
+    }
+
+    @ReactMethod
+    fun recordCrashCandidate(input: ReadableMap, promise: Promise) {
+        runCatching {
+            val candidateId = AnsightRuntime.recordCrashCandidate(
+                runtime = input.stringValue("runtime") ?: "react-native-javascript",
+                kind = input.stringValue("kind") ?: "unhandled_javascript_error",
+                message = input.stringValue("message"),
+                stack = input.stringValue("stack"),
+                fatal = input.booleanValue("fatal", false),
+                metadataJson = input.stringValue("metadata"),
+            )
+            Arguments.createMap().apply { putString("candidateId", candidateId) }
+        }.resolve(promise)
+    }
+
     @ReactMethod
     fun screenViewed(name: String, details: ReadableMap?, promise: Promise) {
         runCatching {
@@ -661,6 +695,16 @@ class AnsightReactNativeModule(
         }
     }
 
+    private fun emitHostConnectionStatusEvent(status: HostConnectionStatus) {
+        if (listenerCount.get() <= 0) return
+        val event = hostConnectionStatusMap(status)
+        UiThreadUtil.runOnUiThread {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("AnsightHostConnectionStatus", event)
+        }
+    }
+
     private fun configureReactNativeMemoryProfiling(map: ReadableMap?) {
         val options = reactNativeMemoryProfilingOptions(map)
         currentReactNativeMemoryOptions = options
@@ -693,6 +737,22 @@ class AnsightReactNativeModule(
         if (map.hasBoolean("enableBatteryLevel")) {
             options = options.copy(enableBatteryLevel = map.booleanValue("enableBatteryLevel", options.enableBatteryLevel))
         }
+        if (map.hasBoolean("enableOpenFileHandleTracking")) {
+            options = options.copy(
+                enableOpenFileHandleTracking = map.booleanValue(
+                    "enableOpenFileHandleTracking",
+                    options.enableOpenFileHandleTracking,
+                ),
+            )
+        }
+        if (map.hasBoolean("enableJniReferenceCountTracking")) {
+            options = options.copy(
+                enableJniReferenceCountTracking = map.booleanValue(
+                    "enableJniReferenceCountTracking",
+                    options.enableJniReferenceCountTracking,
+                ),
+            )
+        }
         if (map.hasMap("defaultMemoryChannels")) {
             val memory = map.getMapOrNull("defaultMemoryChannels")
             val managedHeap = if (memory.hasBoolean("managedHeap")) {
@@ -751,6 +811,10 @@ class AnsightReactNativeModule(
                             AnsightSessionJpegCaptureOptions.DefaultCaptureGpuBackedSurfaces,
                         ),
                         mode = sessionJpegCaptureMode(jpeg.stringValue("mode")),
+                        captureKeyboardPresence = jpeg.booleanValue(
+                            "captureKeyboardPresence",
+                            AnsightSessionJpegCaptureOptions.DefaultCaptureKeyboardPresence,
+                        ),
                     )
                 },
             )
@@ -768,6 +832,24 @@ class AnsightReactNativeModule(
                 },
             )
         }
+        if (map.hasKey("crashCapture")) {
+            options = options.copy(
+                crashCapture = if (map.isFalse("crashCapture")) {
+                    options.crashCapture.copy(enabled = false)
+                } else {
+                    val crash = map.getMapOrNull("crashCapture")
+                    AnsightCrashCaptureOptions(
+                        enabled = crash.booleanValue("enabled", true),
+                        studioHandoffEnabled = crash.booleanValue("studioHandoffEnabled", true),
+                        offlineCaptureAttachmentEnabled = crash.booleanValue("offlineCaptureAttachmentEnabled", true),
+                        maximumPendingReports = crash.intValue("maximumPendingReports", 8),
+                        retentionDays = crash.intValue("retentionDays", 7),
+                        maximumBreadcrumbs = crash.intValue("maximumBreadcrumbs", 64),
+                        maximumTraceBytes = crash.intValue("maximumTraceBytes", 1_048_576),
+                    )
+                },
+            )
+        }
         if (map.hasString("toolGuard")) {
             options = options.copy(toolGuard = toolGuard(map.stringValue("toolGuard")))
         }
@@ -931,14 +1013,18 @@ class AnsightReactNativeModule(
                 AnsightSessionJpegCaptureOptions.DefaultCaptureGpuBackedSurfaces,
             ),
             mode = sessionJpegCaptureMode(map.stringValue("mode")),
+            captureKeyboardPresence = map.booleanValue(
+                "captureKeyboardPresence",
+                AnsightSessionJpegCaptureOptions.DefaultCaptureKeyboardPresence,
+            ),
         )
     }
 
     private fun sessionJpegCaptureMode(value: String?): AnsightSessionJpegCaptureMode =
-        if (value == "screenshotAndVisualTree") {
-            AnsightSessionJpegCaptureMode.ScreenshotAndVisualTree
-        } else {
-            AnsightSessionJpegCaptureMode.ScreenshotOnly
+        when (value) {
+            "screenshotAndVisualTree" -> AnsightSessionJpegCaptureMode.ScreenshotAndVisualTree
+            "screenshotWithVisualTreeOnTouch" -> AnsightSessionJpegCaptureMode.ScreenshotWithVisualTreeOnTouch
+            else -> AnsightSessionJpegCaptureMode.ScreenshotOnly
         }
 
     private fun toolDefinition(map: ReadableMap): ToolDefinition =
@@ -1111,6 +1197,8 @@ class AnsightReactNativeModule(
             putInt("retentionPeriodSeconds", options.retentionPeriodSeconds)
             putBoolean("enableFramesPerSecond", options.enableFramesPerSecond)
             putBoolean("enableBatteryLevel", options.enableBatteryLevel)
+            putBoolean("enableOpenFileHandleTracking", options.enableOpenFileHandleTracking)
+            putBoolean("enableJniReferenceCountTracking", options.enableJniReferenceCountTracking)
             putMap("defaultMemoryChannels", mapOf(
                 "managedHeap" to options.defaultMemoryChannels.javaHeap,
                 "javaHeap" to options.defaultMemoryChannels.javaHeap,
@@ -1127,10 +1215,11 @@ class AnsightReactNativeModule(
                     "quality" to capture.quality,
                     "maxWidth" to capture.maxWidth,
                     "captureGpuBackedSurfaces" to capture.captureGpuBackedSurfaces,
-                    "mode" to if (capture.mode == AnsightSessionJpegCaptureMode.ScreenshotAndVisualTree) {
-                        "screenshotAndVisualTree"
-                    } else {
-                        "screenshotOnly"
+                    "captureKeyboardPresence" to capture.captureKeyboardPresence,
+                    "mode" to when (capture.mode) {
+                        AnsightSessionJpegCaptureMode.ScreenshotAndVisualTree -> "screenshotAndVisualTree"
+                        AnsightSessionJpegCaptureMode.ScreenshotWithVisualTreeOnTouch -> "screenshotWithVisualTreeOnTouch"
+                        else -> "screenshotOnly"
                     },
                 ).toWritableMap())
             } ?: putNull("sessionJpegCapture")

package/index.d.ts

@@ -37,7 +37,8 @@ export interface AnsightSessionJpegCaptureOptions {
   quality?: number;
   maxWidth?: number;
   captureGpuBackedSurfaces?: boolean;
-  mode?: "screenshotOnly" | "screenshotAndVisualTree";
+  captureKeyboardPresence?: boolean;
+  mode?: "screenshotOnly" | "screenshotAndVisualTree" | "screenshotWithVisualTreeOnTouch";
 }
 
 export interface AnsightTouchCaptureOptions {
@@ -47,6 +48,75 @@ export interface AnsightTouchCaptureOptions {
   moveCaptureFramesPerSecond?: number;
 }
 
+export interface AnsightNetworkHeader {
+  name: string;
+  value: string;
+}
+
+export interface AnsightNetworkBody {
+  contentType?: string;
+  encoding: "utf8" | "base64";
+  data: string;
+  capturedBytes: number;
+  totalBytes?: number;
+  truncated: boolean;
+}
+
+/** V1 network metadata with optional, bounded bodies. */
+export interface AnsightNetworkRequest {
+  schema: "ansight.network-request.v1";
+  id: string;
+  source: string;
+  startedAtUtc: string;
+  completedAtUtc: string;
+  durationMilliseconds: number;
+  method: string;
+  url: string;
+  protocol?: string;
+  requestHeaders: AnsightNetworkHeader[];
+  requestBodySizeBytes?: number;
+  requestBody?: AnsightNetworkBody;
+  statusCode?: number;
+  reasonPhrase?: string;
+  responseHeaders: AnsightNetworkHeader[];
+  responseBodySizeBytes?: number;
+  responseBody?: AnsightNetworkBody;
+  errorType?: string;
+  errorMessage?: string;
+}
+
+export type AnsightNetworkRequestInput = Partial<AnsightNetworkRequest> & {
+  method: string;
+  url: string;
+};
+
+export interface AnsightNetworkSanitizationOptions {
+  includeRequestHeaders?: boolean;
+  includeResponseHeaders?: boolean;
+  includeQueryString?: boolean;
+  includeBodySizes?: boolean;
+  /** Defaults to true. */
+  captureRequestBody?: boolean;
+  /** Defaults to true. */
+  captureResponseBody?: boolean;
+  /** Decoded bytes retained per body. Defaults to 64 KiB; larger explicit limits are honored. */
+  maximumBodyBytes?: number;
+  captureBinaryBodies?: boolean;
+  additionalSensitiveHeaderNames?: string[];
+  additionalSensitiveQueryParameterNames?: string[];
+  urlSanitizer?: (url: string) => string;
+  /** Return a replacement request, or null to suppress capture. */
+  requestSanitizer?: (
+    request: AnsightNetworkRequest,
+  ) => AnsightNetworkRequest | null;
+}
+
+export interface AnsightNetworkCaptureOptions
+  extends AnsightNetworkSanitizationOptions {
+  captureFetch?: boolean;
+  captureXmlHttpRequest?: boolean;
+}
+
 export interface AnsightNativeToolRoot {
   alias: string;
   path: string;
@@ -110,6 +180,8 @@ export interface AnsightOptions {
   retentionPeriodSeconds?: number;
   enableFramesPerSecond?: boolean;
   enableBatteryLevel?: boolean;
+  enableOpenFileHandleTracking?: boolean;
+  enableJniReferenceCountTracking?: boolean;
   defaultMemoryChannels?: {
     managedHeap?: boolean;
     physicalFootprint?: boolean;
@@ -121,6 +193,7 @@ export interface AnsightOptions {
   reactNativeMemory?: false | AnsightReactNativeMemoryOptions;
   sessionJpegCapture?: false | AnsightSessionJpegCaptureOptions;
   touchCapture?: false | AnsightTouchCaptureOptions;
+  crashCapture?: false | AnsightCrashCaptureOptions;
   lifecycleCapture?: {
     enabled?: boolean;
     captureAppLifecycle?: boolean;
@@ -151,6 +224,27 @@ export interface AnsightOptions {
   remoteTools?: AnsightRemoteToolsOptions;
   additionalChannels?: AnsightChannel[];
   lifecycle?: boolean;
+  /** Explicitly opt in to fetch/XMLHttpRequest instrumentation. */
+  networkCapture?: boolean | AnsightNetworkCaptureOptions;
+}
+
+export interface AnsightCrashCaptureOptions {
+  enabled?: boolean;
+  studioHandoffEnabled?: boolean;
+  offlineCaptureAttachmentEnabled?: boolean;
+  maximumPendingReports?: number;
+  retentionDays?: number;
+  maximumBreadcrumbs?: number;
+  maximumTraceBytes?: number;
+}
+
+export interface AnsightCrashCandidate {
+  runtime?: string;
+  kind?: string;
+  message?: string;
+  stack?: string;
+  fatal?: boolean;
+  metadata?: string | Record<string, string>;
 }
 
 export interface AnsightOperationResult {
@@ -251,6 +345,10 @@ export class AnsightOptionsBuilder {
   withoutFramesPerSecond(): this;
   withBatteryLevel(): this;
   withoutBatteryLevel(): this;
+  withOpenFileHandleTracking(): this;
+  withoutOpenFileHandleTracking(): this;
+  withJniReferenceCountTracking(): this;
+  withoutJniReferenceCountTracking(): this;
   withRetentionPeriodSeconds(retentionPeriodSeconds: number): this;
   withAdditionalChannels(additionalChannels: AnsightChannel[]): this;
   addAdditionalChannel(additionalChannel: AnsightChannel): this;
@@ -264,12 +362,21 @@ export class AnsightOptionsBuilder {
     quality?: number,
     maxWidth?: number | null,
     captureGpuBackedSurfaces?: boolean,
-    mode?: "screenshotOnly" | "screenshotAndVisualTree"
+    mode?: "screenshotOnly" | "screenshotAndVisualTree" | "screenshotWithVisualTreeOnTouch",
+    captureKeyboardPresence?: boolean
   ): this;
   withoutSessionJpegCapture(): this;
   withTouchCapture(touchCapture?: AnsightTouchCaptureOptions): this;
   withoutTouchCapture(): this;
+  withCrashCapture(crashCapture?: AnsightCrashCaptureOptions): this;
+  withoutCrashCapture(): this;
   withLifecycleCapture(lifecycleCapture?: NonNullable<AnsightOptions["lifecycleCapture"]>): this;
+  withNetworkCapture(networkCapture?: AnsightNetworkCaptureOptions): this;
+  withNetworkRequestBodies(maximumBodyBytes?: number): this;
+  withoutNetworkRequestBodies(): this;
+  withNetworkResponseBodies(maximumBodyBytes?: number): this;
+  withoutNetworkResponseBodies(): this;
+  withoutNetworkCapture(): this;
   withToolGuard(toolGuard: NonNullable<AnsightOptions["toolGuard"]>): this;
   withToolsDisabled(): this;
   withReadOnlyToolAccess(): this;
@@ -512,6 +619,19 @@ export function metric(value: number, channel?: number): Promise<AnsightDebugSna
 export function recordMetric(value: number, channel?: number): Promise<AnsightDebugSnapshot>;
 export function event(input: string | { label: string; type?: string; details?: string; channel?: number }): Promise<AnsightDebugSnapshot>;
 export function recordEvent(input: string | { label: string; type?: string; details?: string; channel?: number }): Promise<AnsightDebugSnapshot>;
+export function recordCrashCandidate(input?: AnsightCrashCandidate): Promise<{ candidateId?: string }>;
+export function recordNetworkRequest(
+  input: AnsightNetworkRequestInput,
+  sanitizationOptions?: AnsightNetworkSanitizationOptions,
+): Promise<AnsightOperationResult>;
+export function sanitizeNetworkRequest(
+  input: AnsightNetworkRequestInput,
+  sanitizationOptions?: AnsightNetworkSanitizationOptions,
+): AnsightNetworkRequest | null;
+export function installNetworkCapture(
+  options?: AnsightNetworkCaptureOptions,
+): AnsightSubscription;
+export function uninstallNetworkCapture(): void;
 export function screenViewed(name: string, details?: Record<string, string>): Promise<AnsightDebugSnapshot>;
 export function trackRoute(name: string, details?: Record<string, string>): Promise<AnsightDebugSnapshot>;
 export function setAppLifecycleState(state: AnsightLifecycleState): Promise<AnsightDebugSnapshot>;
@@ -585,6 +705,8 @@ declare const Ansight: {
   recordMetric: typeof recordMetric;
   event: typeof event;
   recordEvent: typeof recordEvent;
+  recordCrashCandidate: typeof recordCrashCandidate;
+  recordNetworkRequest: typeof recordNetworkRequest;
   screenViewed: typeof screenViewed;
   trackRoute: typeof trackRoute;
   setAppLifecycleState: typeof setAppLifecycleState;
@@ -639,6 +761,9 @@ declare const Ansight: {
   installReactTools: typeof installReactTools;
   uninstallReactTools: typeof uninstallReactTools;
   installErrorHandlers: typeof installErrorHandlers;
+  installNetworkCapture: typeof installNetworkCapture;
+  uninstallNetworkCapture: typeof uninstallNetworkCapture;
+  sanitizeNetworkRequest: typeof sanitizeNetworkRequest;
   createReactNavigationTracker: typeof createReactNavigationTracker;
   platform: "ios" | "android" | string;
 };