react-native-inapp-inspector 2.0.0 → 2.0.2

package/dist/esm/components/Slider.js

@@ -0,0 +1,222 @@
+import React, { useRef, useState, useCallback, useMemo } from 'react';
+import { View, Text, StyleSheet, PanResponder, } from 'react-native';
+import { AppColors } from '../styles/AppColors';
+import { AppFonts } from '../styles/AppFonts';
+import TouchableScale from './TouchableScale';
+export const Slider = React.memo(({ value, onValueChange, min = 50, max = 90, step = 5, formatLabel = val => `${Math.round(val)}%`, quickPresets = [50, 60, 70, 80, 90], disabled = false, }) => {
+    const trackWidthRef = useRef(0);
+    const [trackWidth, setTrackWidth] = useState(0);
+    const [isDragging, setIsDragging] = useState(false);
+    const clampedValue = Math.max(min, Math.min(max, value));
+    const percentage = (clampedValue - min) / (max - min || 1);
+    const updateValueFromPosition = useCallback((pageX, trackPageX) => {
+        if (trackWidthRef.current <= 0)
+            return;
+        const relativeX = Math.max(0, Math.min(trackWidthRef.current, pageX - trackPageX));
+        const rawRatio = relativeX / trackWidthRef.current;
+        let newValue = min + rawRatio * (max - min);
+        if (step > 0) {
+            newValue = Math.round(newValue / step) * step;
+        }
+        newValue = Math.max(min, Math.min(max, newValue));
+        onValueChange(newValue);
+    }, [min, max, step, onValueChange]);
+    const trackContainerRef = useRef(null);
+    const trackPageXRef = useRef(0);
+    const measureTrack = useCallback(() => {
+        if (trackContainerRef.current) {
+            trackContainerRef.current.measure((_x, _y, _width, _height, pageX) => {
+                trackPageXRef.current = pageX;
+            });
+        }
+    }, []);
+    const panResponder = useMemo(() => PanResponder.create({
+        onStartShouldSetPanResponder: () => !disabled,
+        onMoveShouldSetPanResponder: () => !disabled,
+        onPanResponderGrant: (evt) => {
+            setIsDragging(true);
+            measureTrack();
+            updateValueFromPosition(evt.nativeEvent.pageX, trackPageXRef.current);
+        },
+        onPanResponderMove: (evt, _gestureState) => {
+            updateValueFromPosition(evt.nativeEvent.pageX, trackPageXRef.current);
+        },
+        onPanResponderRelease: () => {
+            setIsDragging(false);
+        },
+        onPanResponderTerminate: () => {
+            setIsDragging(false);
+        },
+    }), [disabled, measureTrack, updateValueFromPosition]);
+    const handleLayout = (e) => {
+        const w = e.nativeEvent.layout.width;
+        trackWidthRef.current = w;
+        setTrackWidth(w);
+        measureTrack();
+    };
+    const thumbPosition = percentage * (trackWidth || 0);
+    return (<View style={styles.container}>
+        {/* Value Display Row */}
+        <View style={styles.valueRow}>
+          <Text style={styles.rangeText}>{min}%</Text>
+          <View style={[
+            styles.currentValueBadge,
+            isDragging && styles.currentValueBadgeActive,
+        ]}>
+            <Text style={styles.currentValueText}>{formatLabel(clampedValue)}</Text>
+          </View>
+          <Text style={styles.rangeText}>{max}%</Text>
+        </View>
+
+        {/* Interactive Track Area */}
+        <View ref={trackContainerRef} onLayout={handleLayout} {...panResponder.panHandlers} style={styles.touchArea}>
+          {/* Background Rail */}
+          <View style={styles.rail}>
+            {/* Active Filled Bar */}
+            <View style={[
+            styles.fillBar,
+            { width: `${Math.round(percentage * 100)}%` },
+        ]}/>
+          </View>
+
+          {/* Draggable Thumb */}
+          <View style={[
+            styles.thumb,
+            {
+                left: Math.max(0, Math.min((trackWidth || 0) - 24, thumbPosition - 12)),
+            },
+            isDragging && styles.thumbActive,
+        ]}>
+            <View style={styles.thumbCenterDot}/>
+          </View>
+        </View>
+
+        {/* Quick Presets */}
+        {quickPresets && quickPresets.length > 0 && (<View style={styles.presetRow}>
+            {quickPresets.map(preset => {
+                const isSelected = Math.round(clampedValue) === preset;
+                return (<TouchableScale key={preset} onPress={() => onValueChange(preset)} style={[
+                        styles.presetButton,
+                        isSelected && styles.presetButtonActive,
+                    ]}>
+                  <Text style={[
+                        styles.presetText,
+                        isSelected && styles.presetTextActive,
+                    ]}>
+                    {preset}%
+                  </Text>
+                </TouchableScale>);
+            })}
+          </View>)}
+      </View>);
+});
+const styles = StyleSheet.create({
+    container: {
+        paddingVertical: 4,
+        gap: 8,
+    },
+    valueRow: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        paddingHorizontal: 2,
+    },
+    rangeText: {
+        fontFamily: AppFonts.interMedium,
+        fontSize: 11,
+        color: AppColors.grayText,
+    },
+    currentValueBadge: {
+        backgroundColor: `${AppColors.purple}1A`,
+        borderColor: `${AppColors.purple}33`,
+        borderWidth: 1,
+        borderRadius: 8,
+        paddingHorizontal: 10,
+        paddingVertical: 2.5,
+    },
+    currentValueBadgeActive: {
+        backgroundColor: AppColors.purple,
+        borderColor: AppColors.purple,
+        transform: [{ scale: 1.05 }],
+    },
+    currentValueText: {
+        fontFamily: AppFonts.interBold,
+        fontSize: 12,
+        color: AppColors.purple,
+    },
+    touchArea: {
+        height: 36,
+        justifyContent: 'center',
+        position: 'relative',
+    },
+    rail: {
+        height: 8,
+        backgroundColor: `${AppColors.grayTextWeak}2B`,
+        borderRadius: 4,
+        overflow: 'hidden',
+        position: 'relative',
+    },
+    fillBar: {
+        height: '100%',
+        backgroundColor: AppColors.purple,
+        borderRadius: 4,
+    },
+    thumb: {
+        position: 'absolute',
+        width: 24,
+        height: 24,
+        borderRadius: 12,
+        backgroundColor: AppColors.white,
+        borderWidth: 2.5,
+        borderColor: AppColors.purple,
+        alignItems: 'center',
+        justifyContent: 'center',
+        shadowColor: AppColors.black,
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.18,
+        shadowRadius: 3.5,
+        elevation: 4,
+    },
+    thumbActive: {
+        transform: [{ scale: 1.15 }],
+        shadowOpacity: 0.28,
+        shadowRadius: 5,
+        elevation: 6,
+        borderColor: AppColors.purple,
+    },
+    thumbCenterDot: {
+        width: 6,
+        height: 6,
+        borderRadius: 3,
+        backgroundColor: AppColors.purple,
+    },
+    presetRow: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        gap: 8,
+        marginTop: 2,
+    },
+    presetButton: {
+        flex: 1,
+        paddingVertical: 5,
+        borderRadius: 7,
+        alignItems: 'center',
+        backgroundColor: AppColors.grayBackground,
+        borderWidth: 1,
+        borderColor: AppColors.dividerColor,
+    },
+    presetButtonActive: {
+        backgroundColor: `${AppColors.purple}20`,
+        borderColor: AppColors.purple,
+    },
+    presetText: {
+        fontFamily: AppFonts.interBold,
+        fontSize: 10.5,
+        color: AppColors.grayText,
+    },
+    presetTextActive: {
+        color: AppColors.purple,
+    },
+});
+export default Slider;

package/dist/esm/constants/version.d.ts

@@ -1 +1 @@
-export declare const LIB_VERSION = "2.0.0";
+export declare const LIB_VERSION = "2.0.2";

package/dist/esm/constants/version.js

@@ -1,3 +1,3 @@
 // AUTO-GENERATED FILE — do not edit by hand.
 // Regenerated from package.json on every build by scripts/gen-version.js.
-export const LIB_VERSION = '2.0.0';
+export const LIB_VERSION = '2.0.2';

package/dist/esm/customHooks/analyticsLogger.js

@@ -43,7 +43,7 @@ const addEvent = (event) => {
     if (!isAnalyticsModuleEnabled)
         return;
     events.unshift(event);
-    events = events.slice(0, 200);
+    events = events.slice(0, 75);
     notify();
 };
 // ─── Public subscribe / query API ────────────────────────────────────────────

package/dist/esm/customHooks/crashHandler.js

@@ -10,7 +10,7 @@ let lastHandledErrorTimestamp = 0;
 let crashRecordsStore = [];
 let breadcrumbsStore = [];
 const MAX_BREADCRUMBS = 50;
-let maxStoredCrashes = 100;
+let maxStoredCrashes = 50;
 const appStartTime = Date.now();
 let isCrashModuleEnabled = false;
 export const setCrashModuleEnabled = (enabled) => {

package/dist/esm/helpers/index.d.ts

@@ -1,4 +1,6 @@
 import { NetworkLog, RouteInfo, DiffResult, JsonContent, StackFrameType } from '../types';
+export * from './searchQueryParser';
+export * from './telemetry';
 export declare const getDomainColor: (domain: string) => string;
 export declare const formatDateTime: (timestamp: number) => string;
 export declare const formatTimestamp: (timestamp: number) => string;

package/dist/esm/helpers/index.js

@@ -5,6 +5,8 @@ import { showToast } from './toast';
 import { AppColors } from '../styles/AppColors';
 // Constants
 import { DOMAIN_COLORS, DURATION_FAST_MS, DURATION_SLOW_MS } from '../constants';
+export * from './searchQueryParser';
+export * from './telemetry';
 export const getDomainColor = (domain) => {
     if (!domain)
         return DOMAIN_COLORS[0];

package/dist/esm/helpers/searchQueryParser.d.ts

@@ -0,0 +1,6 @@
+import { NetworkLog } from '../types';
+/**
+ * Parses query strings like `method:POST is:error slow:>1s status:200 auth`
+ * and checks whether a given NetworkLog matches all tokens.
+ */
+export declare function matchNetworkLogQuery(log: NetworkLog, searchQuery: string, routePath?: string): boolean;

package/dist/esm/helpers/searchQueryParser.js

@@ -0,0 +1,233 @@
+/**
+ * Parses query strings like `method:POST is:error slow:>1s status:200 auth`
+ * and checks whether a given NetworkLog matches all tokens.
+ */
+export function matchNetworkLogQuery(log, searchQuery, routePath) {
+    if (!searchQuery || searchQuery.trim().length === 0)
+        return true;
+    const rawTokens = searchQuery
+        .trim()
+        .match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+    if (rawTokens.length === 0)
+        return true;
+    const methodStr = (log.method || '').toLowerCase();
+    const urlStr = (log.url || '').toLowerCase();
+    const statusNum = typeof log.status === 'number' ? log.status : parseInt(String(log.status || 0), 10);
+    const statusStr = String(log.status ?? '');
+    const durationNum = log.duration || 0;
+    const clientStr = (log.client || '').toLowerCase();
+    const reqStr = typeof log.request === 'string' ? log.request : JSON.stringify(log.request || '');
+    const resStr = typeof log.response === 'string' ? log.response : JSON.stringify(log.response || '');
+    const reqHeadersStr = JSON.stringify(log.requestHeaders || '').toLowerCase();
+    const resHeadersStr = JSON.stringify(log.responseHeaders || '').toLowerCase();
+    const pathStr = routePath ? routePath.toLowerCase() : '';
+    const fullSearchCorpus = [
+        methodStr,
+        urlStr,
+        statusStr,
+        pathStr,
+        clientStr,
+        reqStr.toLowerCase(),
+        resStr.toLowerCase(),
+        reqHeadersStr,
+        resHeadersStr,
+    ].join(' ');
+    for (const rawToken of rawTokens) {
+        const token = rawToken.replace(/^["']|["']$/g, '').trim();
+        if (!token)
+            continue;
+        const lowerToken = token.toLowerCase();
+        // 1. method:<VAL> or m:<VAL>
+        if (lowerToken.startsWith('method:') || lowerToken.startsWith('m:')) {
+            const targetMethod = lowerToken.replace(/^(method:|m:)/, '').trim();
+            if (targetMethod.startsWith('!')) {
+                if (methodStr === targetMethod.slice(1))
+                    return false;
+            }
+            else {
+                if (methodStr !== targetMethod)
+                    return false;
+            }
+            continue;
+        }
+        // 2. status:<VAL> or s:<VAL>
+        if (lowerToken.startsWith('status:') || lowerToken.startsWith('s:')) {
+            const val = lowerToken.replace(/^(status:|s:)/, '').trim();
+            if (val.startsWith('>=')) {
+                const threshold = parseInt(val.slice(2), 10);
+                if (isNaN(threshold) || statusNum < threshold)
+                    return false;
+            }
+            else if (val.startsWith('>')) {
+                const threshold = parseInt(val.slice(1), 10);
+                if (isNaN(threshold) || statusNum <= threshold)
+                    return false;
+            }
+            else if (val.startsWith('<=')) {
+                const threshold = parseInt(val.slice(2), 10);
+                if (isNaN(threshold) || statusNum > threshold)
+                    return false;
+            }
+            else if (val.startsWith('<')) {
+                const threshold = parseInt(val.slice(1), 10);
+                if (isNaN(threshold) || statusNum >= threshold)
+                    return false;
+            }
+            else if (val.endsWith('xx') || val.endsWith('x')) {
+                const prefix = val.replace(/x/g, '');
+                if (!statusStr.startsWith(prefix))
+                    return false;
+            }
+            else {
+                const targetCode = parseInt(val, 10);
+                if (!isNaN(targetCode)) {
+                    if (statusNum !== targetCode)
+                        return false;
+                }
+                else if (!statusStr.includes(val)) {
+                    return false;
+                }
+            }
+            continue;
+        }
+        // 3. is:<FLAG>
+        if (lowerToken.startsWith('is:')) {
+            const flag = lowerToken.slice(3).trim();
+            if (flag === 'error' || flag === 'failed' || flag === 'err' || flag === 'fail') {
+                const isErr = log.status === 0 || log.status == null || statusNum >= 400;
+                if (!isErr)
+                    return false;
+            }
+            else if (flag === 'success' || flag === 'ok' || flag === '2xx') {
+                const isSuccess = statusNum >= 200 && statusNum < 300;
+                if (!isSuccess)
+                    return false;
+            }
+            else if (flag === 'slow') {
+                if (durationNum < 1000)
+                    return false;
+            }
+            else if (flag === 'fast') {
+                if (durationNum >= 200)
+                    return false;
+            }
+            else if (flag === 'graphql' || flag === 'gql') {
+                const isGql = urlStr.includes('graphql') ||
+                    clientStr === 'graphql' ||
+                    clientStr === 'apollo';
+                if (!isGql)
+                    return false;
+            }
+            else if (flag === 'https') {
+                if (!urlStr.startsWith('https'))
+                    return false;
+            }
+            else if (flag === 'http') {
+                if (urlStr.startsWith('https') || !urlStr.startsWith('http'))
+                    return false;
+            }
+            else if (flag === 'json') {
+                const isJson = reqHeadersStr.includes('application/json') ||
+                    resHeadersStr.includes('application/json') ||
+                    urlStr.includes('.json');
+                if (!isJson)
+                    return false;
+            }
+            continue;
+        }
+        // 4. slow:<DURATION> or dur:<DURATION> or duration:<DURATION>
+        if (lowerToken.startsWith('slow:') ||
+            lowerToken.startsWith('dur:') ||
+            lowerToken.startsWith('duration:')) {
+            const val = lowerToken.replace(/^(slow:|dur:|duration:)/, '').trim();
+            let thresholdMs = 0;
+            let isGreater = true;
+            let cleanVal = val;
+            if (val.startsWith('>=')) {
+                isGreater = true;
+                cleanVal = val.slice(2);
+            }
+            else if (val.startsWith('>')) {
+                isGreater = true;
+                cleanVal = val.slice(1);
+            }
+            else if (val.startsWith('<=')) {
+                isGreater = false;
+                cleanVal = val.slice(2);
+            }
+            else if (val.startsWith('<')) {
+                isGreater = false;
+                cleanVal = val.slice(1);
+            }
+            if (cleanVal.endsWith('s') && !cleanVal.endsWith('ms')) {
+                thresholdMs = parseFloat(cleanVal.slice(0, -1)) * 1000;
+            }
+            else if (cleanVal.endsWith('ms')) {
+                thresholdMs = parseFloat(cleanVal.slice(0, -2));
+            }
+            else {
+                thresholdMs = parseFloat(cleanVal);
+            }
+            if (!isNaN(thresholdMs)) {
+                if (isGreater) {
+                    if (durationNum < thresholdMs)
+                        return false;
+                }
+                else {
+                    if (durationNum > thresholdMs)
+                        return false;
+                }
+            }
+            continue;
+        }
+        // 5. client:<CLIENT> or c:<CLIENT>
+        if (lowerToken.startsWith('client:') || lowerToken.startsWith('c:')) {
+            const targetClient = lowerToken.replace(/^(client:|c:)/, '').trim();
+            if (!clientStr.includes(targetClient))
+                return false;
+            continue;
+        }
+        // 6. domain:<DOMAIN> or d:<DOMAIN>
+        if (lowerToken.startsWith('domain:') || lowerToken.startsWith('d:')) {
+            const targetDomain = lowerToken.replace(/^(domain:|d:)/, '').trim();
+            if (!urlStr.includes(targetDomain))
+                return false;
+            continue;
+        }
+        // 7. path:<PATH> or p:<PATH>
+        if (lowerToken.startsWith('path:') || lowerToken.startsWith('p:')) {
+            const targetPath = lowerToken.replace(/^(path:|p:)/, '').trim();
+            if (!urlStr.includes(targetPath) && !pathStr.includes(targetPath)) {
+                return false;
+            }
+            continue;
+        }
+        // 8. req:<TERM> or body:<TERM>
+        if (lowerToken.startsWith('req:') || lowerToken.startsWith('body:')) {
+            const target = lowerToken.replace(/^(req:|body:)/, '').trim();
+            if (!reqStr.toLowerCase().includes(target))
+                return false;
+            continue;
+        }
+        // 9. res:<TERM>
+        if (lowerToken.startsWith('res:')) {
+            const target = lowerToken.slice(4).trim();
+            if (!resStr.toLowerCase().includes(target))
+                return false;
+            continue;
+        }
+        // 10. header:<TERM> or h:<TERM>
+        if (lowerToken.startsWith('header:') || lowerToken.startsWith('h:')) {
+            const target = lowerToken.replace(/^(header:|h:)/, '').trim();
+            if (!reqHeadersStr.includes(target) && !resHeadersStr.includes(target)) {
+                return false;
+            }
+            continue;
+        }
+        // 11. Generic Plain Substring Match
+        if (!fullSearchCorpus.includes(lowerToken)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/esm/helpers/settingsStore.js

@@ -101,19 +101,19 @@ export function getCustomStorage() {
 export function calculateRamBasedLimits(freeRamMb) {
     if (freeRamMb >= 3000) {
         return {
-            maxNetworkLogs: 1000,
-            maxConsoleLogs: 1500,
-            maxAnalyticsEvents: 500,
-            maxCrashRecords: 100,
+            maxNetworkLogs: 100,
+            maxConsoleLogs: 100,
+            maxAnalyticsEvents: 75,
+            maxCrashRecords: 50,
             profileName: 'High-End',
             freeRamMb,
         };
     }
     else if (freeRamMb >= 1500) {
         return {
-            maxNetworkLogs: 500,
-            maxConsoleLogs: 750,
-            maxAnalyticsEvents: 250,
+            maxNetworkLogs: 100,
+            maxConsoleLogs: 100,
+            maxAnalyticsEvents: 75,
             maxCrashRecords: 50,
             profileName: 'Standard',
             freeRamMb,
@@ -121,9 +121,9 @@ export function calculateRamBasedLimits(freeRamMb) {
     }
     else if (freeRamMb >= 600) {
         return {
-            maxNetworkLogs: 200,
-            maxConsoleLogs: 300,
-            maxAnalyticsEvents: 100,
+            maxNetworkLogs: 100,
+            maxConsoleLogs: 100,
+            maxAnalyticsEvents: 50,
             maxCrashRecords: 25,
             profileName: 'Compact',
             freeRamMb,
@@ -131,9 +131,9 @@ export function calculateRamBasedLimits(freeRamMb) {
     }
     else {
         return {
-            maxNetworkLogs: 100,
-            maxConsoleLogs: 150,
-            maxAnalyticsEvents: 50,
+            maxNetworkLogs: 50,
+            maxConsoleLogs: 50,
+            maxAnalyticsEvents: 25,
             maxCrashRecords: 15,
             profileName: 'Ultra-Light',
             freeRamMb,

package/dist/esm/helpers/telemetry.d.ts

@@ -0,0 +1,99 @@
+export declare const GA4_MEASUREMENT_ID = "G-XXXXXXXXXX";
+export declare const GA4_API_SECRET = "YOUR_GA4_API_SECRET";
+/**
+ * Asynchronously loads host application and device metadata (strictly non-PII/technical).
+ */
+export declare function loadAppDiagnosticsAsync(): Promise<Record<string, any>>;
+/**
+ * Returns the developer's telemetry consent status.
+ */
+export declare function getTelemetryConsentStatus(): Promise<'granted' | 'declined' | 'undetermined'>;
+/**
+ * Saves the developer's telemetry consent choice.
+ */
+export declare function setTelemetryConsent(granted: boolean): Promise<void>;
+/**
+ * Checks if the user or environment has opted out of telemetry.
+ */
+export declare function isTelemetryOptedOut(explicitSetting?: boolean): boolean;
+/**
+ * Track an anonymous event via GA4 Measurement Protocol.
+ */
+export declare function trackTelemetryEvent(eventName: string, params?: Record<string, any>, options?: {
+    telemetry?: boolean;
+    force?: boolean;
+}): Promise<void>;
+/**
+ * 1. Session initialization heartbeat ping.
+ */
+export declare function sendSessionTelemetryPing(options?: {
+    telemetry?: boolean;
+    environment?: string;
+    hasNavigation?: boolean;
+    hasAppIcon?: boolean;
+    force?: boolean;
+}): Promise<void>;
+/**
+ * 2. Track when the inspector modal is opened.
+ */
+export declare function trackInspectorOpen(options?: {
+    activeTab?: string;
+    openSource?: 'fab' | 'shake' | 'programmatic';
+    telemetry?: boolean;
+}): void;
+/**
+ * 3. Track when the inspector modal is closed.
+ */
+export declare function trackInspectorClose(options?: {
+    telemetry?: boolean;
+}): void;
+/**
+ * 4. Track tab / page view navigation inside the inspector.
+ */
+export declare function trackTabSwitch(tabName: string, options?: {
+    telemetry?: boolean;
+    fromTab?: string;
+}): void;
+/**
+ * 5. Track network API interaction (inspect details, copy cURL, retry).
+ */
+export declare function trackNetworkInteraction(action: 'view_detail' | 'copy_curl' | 'retry_request' | 'copy_url' | 'clear_logs' | 'export_har', options?: {
+    method?: string;
+    statusCode?: number;
+    durationMs?: number;
+    telemetry?: boolean;
+}): void;
+/**
+ * 6. Track Redux / State management interaction.
+ */
+export declare function trackReduxInteraction(action: 'view_diff' | 'view_state' | 'view_action' | 'filter_reducer', options?: {
+    reducerName?: string;
+    telemetry?: boolean;
+}): void;
+/**
+ * 7. Track Crash & Exception interaction.
+ */
+export declare function trackCrashInteraction(action: 'view_crash_detail' | 'share_crash_report' | 'copy_stacktrace' | 'clear_crashes', options?: {
+    crashType?: string;
+    telemetry?: boolean;
+}): void;
+/**
+ * 8. Track Performance monitoring tab interaction.
+ */
+export declare function trackPerformanceInteraction(subTab: 'fps' | 'memory' | 'rerenders' | 'bundles', options?: {
+    telemetry?: boolean;
+}): void;
+/**
+ * 9. Track search queries and filter applications.
+ */
+export declare function trackSearchOrFilter(target: 'apis' | 'console' | 'redux' | 'crashes' | 'analytics', actionType: 'search_query' | 'status_filter' | 'method_filter' | 'tag_filter', options?: {
+    filterValue?: string;
+    telemetry?: boolean;
+}): void;
+/**
+ * 10. Track when logs / reports are exported or shared.
+ */
+export declare function trackLogExport(exportType: 'logs_json' | 'logs_har' | 'curl' | 'crash_report', options?: {
+    telemetry?: boolean;
+    count?: number;
+}): void;