@sentry/react-native 5.28.0 → 6.0.0-alpha.0

package/ts3.8/dist/js/replay/mobilereplay.d.ts

@@ -1,4 +1,4 @@
-import type { IntegrationFnResult } from '@sentry/types';
+import type { Integration } from '@sentry/types';
 export declare const MOBILE_REPLAY_INTEGRATION_NAME = "MobileReplay";
 export interface MobileReplayOptions {
     /**
@@ -21,7 +21,7 @@ export interface MobileReplayOptions {
      */
     maskAllVectors?: boolean;
 }
-type MobileReplayIntegration = IntegrationFnResult & {
+type MobileReplayIntegration = Integration & {
     options: Required<MobileReplayOptions>;
 };
 /**

package/ts3.8/dist/js/scopeSync.d.ts

@@ -0,0 +1,6 @@
+import type { Scope } from '@sentry/types';
+/**
+ * Hooks into the scope set methods and sync new data added to the given scope with the native SDKs.
+ */
+export declare function enableSyncToNative(scope: Scope): void;
+//# sourceMappingURL=scopeSync.d.ts.map

package/ts3.8/dist/js/sdk.d.ts

@@ -1,6 +1,4 @@
-import type { Scope } from '@sentry/core';
-import { Hub } from '@sentry/core';
-import type { UserFeedback } from '@sentry/types';
+import type { Scope, UserFeedback } from '@sentry/types';
 import * as React from 'react';
 import type { ReactNativeOptions, ReactNativeWrapperOptions } from './options';
 /**
@@ -11,18 +9,6 @@ export declare function init(passedOptions: ReactNativeOptions): void;
  * Inits the Sentry React Native SDK with automatic instrumentation and wrapped features.
  */
 export declare function wrap<P extends Record<string, unknown>>(RootComponent: React.ComponentType<P>, options?: ReactNativeWrapperOptions): React.ComponentType<P>;
-/**
- * Deprecated. Sets the release on the event.
- * NOTE: Does not set the release on sessions.
- * @deprecated
- */
-export declare function setRelease(release: string): void;
-/**
- * Deprecated. Sets the dist on the event.
- * NOTE: Does not set the dist on sessions.
- * @deprecated
- */
-export declare function setDist(dist: string): void;
 /**
  * If native client is available it will trigger a native crash.
  * Use this only for testing purposes.
@@ -55,9 +41,4 @@ export declare function captureUserFeedback(feedback: UserFeedback): void;
  * @param callback that will be enclosed into push/popScope.
  */
 export declare function withScope<T>(callback: (scope: Scope) => T): T | undefined;
-/**
- * Callback to set context information onto the scope.
- * @param callback Callback function that receives Scope.
- */
-export declare function configureScope(callback: (scope: Scope) => void): ReturnType<Hub['configureScope']>;
 //# sourceMappingURL=sdk.d.ts.map

package/ts3.8/dist/js/touchevents.d.ts

@@ -38,7 +38,6 @@ declare class TouchEventBoundary extends React.Component<TouchEventBoundaryProps
     static displayName: string;
     static defaultProps: Partial<TouchEventBoundaryProps>;
     readonly name: string;
-    private _tracingIntegration;
     /**
      * Registers the TouchEventBoundary as a Sentry Integration.
      */

package/ts3.8/dist/js/tracing/gesturetracing.d.ts

@@ -1,11 +1,7 @@
-import type { Hub } from '@sentry/types';
 export declare const DEFAULT_BREADCRUMB_CATEGORY = "gesture";
 export declare const DEFAULT_BREADCRUMB_TYPE = "user";
 export declare const GESTURE_POSTFIX_LENGTH: number;
 export declare const ACTION_GESTURE_FALLBACK = "gesture";
-interface GestureTracingOptions {
-    getCurrentHub: () => Hub;
-}
 /**
  * Patches React Native Gesture Handler v2 Gesture to start a transaction on gesture begin with the appropriate label.
  * Example: ShoppingCartScreen.dismissGesture
@@ -15,6 +11,5 @@ export declare function sentryTraceGesture<GestureT>(
  * Label of the gesture to be used in transaction name.
  * Example: dismissGesture
  */
-label: string, gesture: GestureT, options?: Partial<GestureTracingOptions>): GestureT;
-export {};
+label: string, gesture: GestureT): GestureT;
 //# sourceMappingURL=gesturetracing.d.ts.map

package/ts3.8/dist/js/tracing/index.d.ts

@@ -1,10 +1,9 @@
-export { ReactNativeTracing } from './reactnativetracing';
-export type { RoutingInstrumentationInstance } from './routingInstrumentation';
-export { RoutingInstrumentation } from './routingInstrumentation';
-export { ReactNavigationInstrumentation, ReactNavigationV5Instrumentation, } from './reactnavigation';
-export { ReactNavigationV4Instrumentation } from './reactnavigationv4';
-export { ReactNativeNavigationInstrumentation } from './reactnativenavigation';
-export type { ReactNavigationCurrentRoute, ReactNavigationRoute, ReactNavigationTransactionContext } from './types';
+export { reactNativeTracingIntegration, INTEGRATION_NAME as REACT_NATIVE_TRACING_INTEGRATION_NAME, getCurrentReactNativeTracingIntegration, getReactNativeTracingIntegration, } from './reactnativetracing';
+export type { ReactNativeTracingIntegration } from './reactnativetracing';
+export { reactNavigationIntegration } from './reactnavigation';
+export { reactNativeNavigationIntegration } from './reactnativenavigation';
+export { startIdleNavigationSpan, startIdleSpan, getDefaultIdleNavigationSpanOptions } from './span';
+export type { ReactNavigationCurrentRoute, ReactNavigationRoute } from './types';
 export { ReactNativeProfiler } from './reactnativeprofiler';
 export { sentryTraceGesture } from './gesturetracing';
 export * from './ops';

package/ts3.8/dist/js/tracing/integrations/appStart.d.ts

@@ -0,0 +1,39 @@
+import type { Integration } from '@sentry/types';
+export type AppStartIntegration = Integration & {
+    captureStandaloneAppStart: () => Promise<void>;
+};
+/**
+ * Records the application start end.
+ * Used automatically by `Sentry.wrap` and `Sentry.ReactNativeProfiler`.
+ */
+export declare function captureAppStart(): Promise<void>;
+/**
+ * Sets the root component first constructor call timestamp.
+ * Used automatically by `Sentry.wrap` and `Sentry.ReactNativeProfiler`.
+ */
+export declare function setRootComponentCreationTimestampMs(timestampMs: number): void;
+/**
+ * For internal use only.
+ *
+ * @private
+ */
+export declare const _setAppStartEndTimestampMs: (timestampMs: number) => void;
+/**
+ * For testing purposes only.
+ *
+ * @private
+ */
+export declare function _clearRootComponentCreationTimestampMs(): void;
+/**
+ * Adds AppStart spans from the native layer to the transaction event.
+ */
+export declare const appStartIntegration: ({ standalone, }?: {
+    /**
+     * Should the integration send App Start as a standalone root span (transaction)?
+     * If false, App Start will be added as a child span to the first transaction.
+     *
+     * @default false
+     */
+    standalone?: boolean;
+}) => AppStartIntegration;
+//# sourceMappingURL=appStart.d.ts.map

package/ts3.8/dist/js/tracing/integrations/nativeFrames.d.ts

@@ -0,0 +1,20 @@
+import type { Integration, Measurements, MeasurementUnit } from '@sentry/types';
+export interface FramesMeasurements extends Measurements {
+    frames_total: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+    frames_slow: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+    frames_frozen: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+}
+/**
+ * Instrumentation to add native slow/frozen frames measurements onto transactions.
+ */
+export declare const nativeFramesIntegration: () => Integration;
+//# sourceMappingURL=nativeFrames.d.ts.map

package/ts3.8/dist/js/tracing/integrations/stalltracking.d.ts

@@ -0,0 +1,31 @@
+import type { Integration, Measurements, MeasurementUnit } from '@sentry/types';
+import { STALL_COUNT, STALL_LONGEST_TIME, STALL_TOTAL_TIME } from '../../measurements';
+export interface StallMeasurements extends Measurements {
+    [STALL_COUNT]: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+    [STALL_TOTAL_TIME]: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+    [STALL_LONGEST_TIME]: {
+        value: number;
+        unit: MeasurementUnit;
+    };
+}
+/**
+ * Stall measurement tracker inspired by the `JSEventLoopWatchdog` used internally in React Native:
+ * https://github.com/facebook/react-native/blob/006f5afe120c290a37cf6ff896748fbc062bf7ed/Libraries/Interaction/JSEventLoopWatchdog.js
+ *
+ * However, we modified the interval implementation to instead have a fixed loop timeout interval of `LOOP_TIMEOUT_INTERVAL_MS`.
+ * We then would consider that iteration a stall when the total time for that interval to run is greater than `LOOP_TIMEOUT_INTERVAL_MS + minimumStallThreshold`
+ */
+export declare const stallTrackingIntegration: ({ minimumStallThresholdMs, }?: {
+    /**
+     * How long in milliseconds an event loop iteration can be delayed for before being considered a "stall."
+     * @default 50
+     */
+    minimumStallThresholdMs?: number;
+}) => Integration;
+//# sourceMappingURL=stalltracking.d.ts.map

package/ts3.8/dist/js/tracing/integrations/userInteraction.d.ts

@@ -0,0 +1,11 @@
+import type { Integration, Span } from '@sentry/types';
+export declare const userInteractionIntegration: () => Integration;
+/**
+ * Starts a new transaction for a user interaction.
+ * @param userInteractionId Consists of `op` representation UI Event and `elementId` unique element identifier on current screen.
+ */
+export declare const startUserInteractionSpan: (userInteractionId: {
+    elementId: string | undefined;
+    op: string;
+}) => Span | undefined;
+//# sourceMappingURL=userInteraction.d.ts.map

package/ts3.8/dist/js/tracing/onSpanEndUtils.d.ts

@@ -0,0 +1,17 @@
+import type { Client, Span } from '@sentry/types';
+/**
+ * Hooks on span end event to execute a callback when the span ends.
+ */
+export declare function onThisSpanEnd(client: Client, span: Span, callback: (span: Span) => void): void;
+export declare const adjustTransactionDuration: (client: Client, span: Span, maxDurationMs: number) => void;
+export declare const ignoreEmptyBackNavigation: (client: Client | undefined, span: Span) => void;
+/**
+ * Idle Transaction callback to only sample transactions with child spans.
+ * To avoid side effects of other callbacks this should be hooked as the last callback.
+ */
+export declare const onlySampleIfChildSpans: (client: Client, span: Span) => void;
+/**
+ * Hooks on AppState change to cancel the span if the app goes background.
+ */
+export declare const cancelInBackground: (client: Client, span: Span) => void;
+//# sourceMappingURL=onSpanEndUtils.d.ts.map

package/ts3.8/dist/js/tracing/origin.d.ts

@@ -0,0 +1,2 @@
+export declare const SPAN_ORIGIN_AUTO_INTERACTION = "auto.interaction";
+//# sourceMappingURL=origin.d.ts.map

package/ts3.8/dist/js/tracing/reactnativenavigation.d.ts

@@ -1,23 +1,35 @@
+import type { Integration } from '@sentry/types';
 import type { EmitterSubscription } from '../utils/rnlibrariesinterface';
-import type { OnConfirmRoute, TransactionCreator } from './routingInstrumentation';
-import { InternalRoutingInstrumentation } from './routingInstrumentation';
-import type { BeforeNavigate } from './types';
+export declare const INTEGRATION_NAME = "ReactNativeNavigation";
 interface ReactNativeNavigationOptions {
     /**
      * How long the instrumentation will wait for the route to mount after a change has been initiated,
      * before the transaction is discarded.
-     * Time is in ms.
      *
-     * Default: 1000
+     * @default 1_000 (ms)
      */
-    routeChangeTimeoutMs: number;
+    routeChangeTimeoutMs?: number;
     /**
      * Instrumentation will create a transaction on tab change.
      * By default only navigation commands create transactions.
      *
-     * Default: true
+     * @default false
      */
-    enableTabsInstrumentation: boolean;
+    enableTabsInstrumentation?: boolean;
+    /**
+     * Does not sample transactions that are from routes that have been seen any more and don't have any spans.
+     * This removes a lot of the clutter as most back navigation transactions are now ignored.
+     *
+     * @default true
+     */
+    ignoreEmptyBackNavigationTransactions?: boolean;
+    /** The React Native Navigation `NavigationDelegate`.
+     *
+     * ```js
+     * import { Navigation } from 'react-native-navigation';
+     * ```
+     */
+    navigation: unknown;
 }
 interface ComponentEvent {
     componentId: string;
@@ -50,36 +62,6 @@ export interface NavigationDelegate {
  * - `_onComponentWillAppear` is then called AFTER the state change happens due to a dispatch and sets the route context onto the active transaction.
  * - If `_onComponentWillAppear` isn't called within `options.routeChangeTimeoutMs` of the dispatch, then the transaction is not sampled and finished.
  */
-export declare class ReactNativeNavigationInstrumentation extends InternalRoutingInstrumentation {
-    static instrumentationName: string;
-    readonly name: string;
-    private _navigation;
-    private _options;
-    private _prevComponentEvent;
-    private _latestTransaction?;
-    private _recentComponentIds;
-    private _stateChangeTimeout?;
-    constructor(
-    /** The react native navigation `NavigationDelegate`. This is usually the import named `Navigation`. */
-    navigation: unknown, options?: Partial<ReactNativeNavigationOptions>);
-    /**
-     * Registers the event listeners for React Native Navigation
-     */
-    registerRoutingInstrumentation(listener: TransactionCreator, beforeNavigate: BeforeNavigate, onConfirmRoute: OnConfirmRoute): void;
-    /**
-     * To be called when a navigation is initiated. (Command, BottomTabSelected, etc.)
-     */
-    private _onNavigation;
-    /**
-     * To be called AFTER the state has been changed to populate the transaction with the current route.
-     */
-    private _onComponentWillAppear;
-    /** Creates final transaction context before confirmation */
-    private _prepareFinalContext;
-    /** Cancels the latest transaction so it does not get sent to Sentry. */
-    private _discardLatestTransaction;
-    /** Cancels the latest transaction so it does not get sent to Sentry. */
-    private _clearStateChangeTimeout;
-}
+export declare const reactNativeNavigationIntegration: ({ navigation: optionsNavigation, routeChangeTimeoutMs, enableTabsInstrumentation, ignoreEmptyBackNavigationTransactions, }: ReactNativeNavigationOptions) => Integration;
 export {};
 //# sourceMappingURL=reactnativenavigation.d.ts.map

package/ts3.8/dist/js/tracing/reactnativetracing.d.ts

@@ -1,183 +1,67 @@
-import type { RequestInstrumentationOptions } from '@sentry/browser';
-import type { Hub, Transaction } from '@sentry/core';
-import type { EventProcessor, Integration, Transaction as TransactionType } from '@sentry/types';
-import type { RoutingInstrumentationInstance } from '../tracing/routingInstrumentation';
-import { NativeFramesInstrumentation } from './nativeframes';
-import { StallTrackingInstrumentation } from './stalltracking';
-import type { BeforeNavigate } from './types';
-export interface ReactNativeTracingOptions extends RequestInstrumentationOptions {
+import type { Client, Integration, StartSpanOptions } from '@sentry/types';
+export declare const INTEGRATION_NAME = "ReactNativeTracing";
+export interface ReactNativeTracingOptions {
     /**
-     * @deprecated Replaced by idleTimeoutMs
-     */
-    idleTimeout: number;
-    /**
-     * @deprecated Replaced by maxTransactionDurationMs
-     */
-    maxTransactionDuration: number;
-    /**
-     * The time to wait in ms until the transaction will be finished. The transaction will use the end timestamp of
-     * the last finished span as the endtime for the transaction.
-     * Time is in ms.
+     * The time that has to pass without any span being created.
+     * If this time is exceeded, the idle span will finish.
      *
-     * Default: 1000
+     * @default 1_000 (ms)
      */
-    idleTimeoutMs: number;
+    idleTimeoutMs?: number;
     /**
-     * The maximum duration (transaction duration + idle timeout) of a transaction
-     * before it will be marked as "deadline_exceeded".
-     * If you never want to mark a transaction set it to 0.
-     * Time is in ms.
+     * The max. time an idle span may run.
+     * If this time is exceeded, the idle span will finish no matter what.
      *
-     * Default: 600000
+     * @default 60_0000 (ms)
      */
-    finalTimeoutMs: number;
+    finalTimeoutMs?: number;
     /**
-     * The routing instrumentation to be used with the tracing integration.
-     * There is no routing instrumentation if nothing is passed.
-     */
-    routingInstrumentation?: RoutingInstrumentationInstance;
-    /**
-     * Does not sample transactions that are from routes that have been seen any more and don't have any spans.
-     * This removes a lot of the clutter as most back navigation transactions are now ignored.
+     * Flag to disable patching all together for fetch requests.
      *
-     * Default: true
+     * @default true
      */
-    ignoreEmptyBackNavigationTransactions: boolean;
+    traceFetch: boolean;
     /**
-     * beforeNavigate is called before a navigation transaction is created and allows users to modify transaction
-     * context data, or drop the transaction entirely (by setting `sampled = false` in the context).
-     *
-     * @param context: The context data which will be passed to `startTransaction` by default
+     * Flag to disable patching all together for xhr requests.
      *
-     * @returns A (potentially) modified context object, with `sampled = false` if the transaction should be dropped.
+     * @default true
      */
-    beforeNavigate: BeforeNavigate;
+    traceXHR: boolean;
     /**
-     * Track the app start time by adding measurements to the first route transaction. If there is no routing instrumentation
-     * an app start transaction will be started.
+     * If true, Sentry will capture http timings and add them to the corresponding http spans.
      *
-     * Default: true
+     * @default true
      */
-    enableAppStartTracking: boolean;
+    enableHTTPTimings: boolean;
     /**
-     * Track slow/frozen frames from the native layer and adds them as measurements to all transactions.
+     * A callback which is called before a span for a navigation is started.
+     * It receives the options passed to `startSpan`, and expects to return an updated options object.
      */
-    enableNativeFramesTracking: boolean;
+    beforeStartSpan?: (options: StartSpanOptions) => StartSpanOptions;
     /**
-     * Track when and how long the JS event loop stalls for. Adds stalls as measurements to all transactions.
-     */
-    enableStallTracking: boolean;
-    /**
-     * Trace User Interaction events like touch and gestures.
+     * This function will be called before creating a span for a request with the given url.
+     * Return false if you don't want a span for the given url.
+     *
+     * @default (url: string) => true
      */
-    enableUserInteractionTracing: boolean;
+    shouldCreateSpanForRequest?(this: void, url: string): boolean;
 }
+export declare const defaultReactNativeTracingOptions: ReactNativeTracingOptions;
+export type ReactNativeTracingState = {
+    currentRoute: string | undefined;
+};
+export declare const reactNativeTracingIntegration: (options?: Partial<ReactNativeTracingOptions>) => Integration & {
+    options: ReactNativeTracingOptions;
+    state: ReactNativeTracingState;
+    setCurrentRoute: (route: string) => void;
+};
+export type ReactNativeTracingIntegration = ReturnType<typeof reactNativeTracingIntegration>;
 /**
- * Tracing integration for React Native.
+ * Returns the current React Native Tracing integration.
  */
-export declare class ReactNativeTracing implements Integration {
-    /**
-     * @inheritDoc
-     */
-    static id: string;
-    /** We filter out App starts more than 60s */
-    private static _maxAppStart;
-    /** We filter out App starts which timestamp is 60s and more before the transaction start */
-    private static _maxAppStartBeforeTransactionMs;
-    /**
-     * @inheritDoc
-     */
-    name: string;
-    /** ReactNativeTracing options */
-    options: ReactNativeTracingOptions;
-    nativeFramesInstrumentation?: NativeFramesInstrumentation;
-    stallTrackingInstrumentation?: StallTrackingInstrumentation;
-    useAppStartWithProfiler: boolean;
-    private _inflightInteractionTransaction?;
-    private _getCurrentHub?;
-    private _awaitingAppStartData?;
-    private _appStartFinishTimestamp?;
-    private _currentRoute?;
-    private _hasSetTracePropagationTargets;
-    private _hasSetTracingOrigins;
-    private _currentViewName;
-    private _firstConstructorCallTimestampMs;
-    constructor(options?: Partial<ReactNativeTracingOptions>);
-    /**
-     *  Registers routing and request instrumentation.
-     */
-    setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): Promise<void>;
-    /**
-     * To be called on a transaction start. Can have async methods
-     */
-    onTransactionStart(transaction: Transaction): void;
-    /**
-     * To be called on a transaction finish. Cannot have async methods.
-     */
-    onTransactionFinish(transaction: Transaction, endTimestamp?: number): void;
-    /**
-     * Called by the ReactNativeProfiler component on first component mount.
-     */
-    onAppStartFinish(endTimestamp: number): void;
-    /**
-     * Sets the root component first constructor call timestamp.
-     */
-    setRootComponentFirstConstructorCallTimestampMs(timestamp: number): void;
-    /**
-     * Starts a new transaction for a user interaction.
-     * @param userInteractionId Consists of `op` representation UI Event and `elementId` unique element identifier on current screen.
-     */
-    startUserInteractionTransaction(userInteractionId: {
-        elementId: string | undefined;
-        op: string;
-    }): TransactionType | undefined;
-    /**
-     * Enables or disables native frames tracking based on the `enableNativeFramesTracking` option.
-     */
-    private _enableNativeFramesTracking;
-    /**
-     *  Sets the current view name into the app context.
-     *  @param event Le event.
-     */
-    private _getCurrentViewEventProcessor;
-    /**
-     * Returns the App Start Duration in Milliseconds. Also returns undefined if not able do
-     * define the duration.
-     */
-    private _getAppStartDurationMilliseconds;
-    /**
-     * Instruments the app start measurements on the first route transaction.
-     * Starts a route transaction if there isn't routing instrumentation.
-     */
-    private _instrumentAppStart;
-    /**
-     * Adds app start measurements and starts a child span on a transaction.
-     */
-    private _addAppStartData;
-    /**
-     * Adds JS Execution before React Root. If `Sentry.wrap` is not used, create a span for the start of JS Bundle execution.
-     */
-    private _addJSExecutionBeforeRoot;
-    /**
-     * Adds native spans to the app start span.
-     */
-    private _addNativeSpansTo;
-    /**
-     * UIKit init is measured by the native layers till the native SDK start
-     * RN initializes the native SDK later, the end timestamp would be wrong
-     */
-    private _createUIKitSpan;
-    /** To be called when the route changes, but BEFORE the components of the new route mount. */
-    private _onRouteWillChange;
-    /**
-     * Creates a breadcrumb and sets the current route as a tag.
-     */
-    private _onConfirmRoute;
-    /** Create routing idle transaction. */
-    private _createRouteTransaction;
-    /**
-     * Start app state aware idle transaction on the scope.
-     */
-    private _startIdleTransaction;
-}
+export declare function getCurrentReactNativeTracingIntegration(): ReactNativeTracingIntegration | undefined;
+/**
+ * Returns React Native Tracing integration of given client.
+ */
+export declare function getReactNativeTracingIntegration(client: Client): ReactNativeTracingIntegration | undefined;
 //# sourceMappingURL=reactnativetracing.d.ts.map

package/ts3.8/dist/js/tracing/reactnavigation.d.ts

@@ -1,18 +1,11 @@
-import type { OnConfirmRoute, TransactionCreator } from './routingInstrumentation';
-import { InternalRoutingInstrumentation } from './routingInstrumentation';
-import type { BeforeNavigate } from './types';
-export interface NavigationRoute {
-    name: string;
-    key: string;
-    params?: Record<string, any>;
-}
-interface ReactNavigationOptions {
+import type { Integration } from '@sentry/types';
+export declare const INTEGRATION_NAME = "ReactNavigation";
+interface ReactNavigationIntegrationOptions {
     /**
      * How long the instrumentation will wait for the route to mount after a change has been initiated,
      * before the transaction is discarded.
-     * Time is in ms.
      *
-     * @default 1000
+     * @default 1_000 (ms)
      */
     routeChangeTimeoutMs: number;
     /**
@@ -22,6 +15,13 @@ interface ReactNavigationOptions {
      * @default false
      */
     enableTimeToInitialDisplay: boolean;
+    /**
+     * Does not sample transactions that are from routes that have been seen any more and don't have any spans.
+     * This removes a lot of the clutter as most back navigation transactions are now ignored.
+     *
+     * @default true
+     */
+    ignoreEmptyBackNavigationTransactions: boolean;
 }
 /**
  * Instrumentation for React-Navigation V5 and above. See docs or sample app for usage.
@@ -31,62 +31,17 @@ interface ReactNavigationOptions {
  * - `_onStateChange` is then called AFTER the state change happens due to a dispatch and sets the route context onto the active transaction.
  * - If `_onStateChange` isn't called within `STATE_CHANGE_TIMEOUT_DURATION` of the dispatch, then the transaction is not sampled and finished.
  */
-export declare class ReactNavigationInstrumentation extends InternalRoutingInstrumentation {
-    static instrumentationName: string;
-    readonly name: string;
-    private _navigationContainer;
-    private _newScreenFrameEventEmitter;
-    private readonly _maxRecentRouteLen;
-    private _latestRoute?;
-    private _latestTransaction?;
-    private _navigationProcessingSpan?;
-    private _initialStateHandled;
-    private _stateChangeTimeout?;
-    private _recentRouteKeys;
-    private _options;
-    constructor(options?: Partial<ReactNavigationOptions>);
-    /**
-     * Extends by calling _handleInitialState at the end.
-     */
-    registerRoutingInstrumentation(listener: TransactionCreator, beforeNavigate: BeforeNavigate, onConfirmRoute: OnConfirmRoute): void;
+export declare const reactNavigationIntegration: ({ routeChangeTimeoutMs, enableTimeToInitialDisplay, ignoreEmptyBackNavigationTransactions, }?: Partial<ReactNavigationIntegrationOptions>) => Integration & {
     /**
      * Pass the ref to the navigation container to register it to the instrumentation
      * @param navigationContainerRef Ref to a `NavigationContainer`
      */
-    registerNavigationContainer(navigationContainerRef: any): void;
-    /**
-     * To be called on every React-Navigation action dispatch.
-     * It does not name the transaction or populate it with route information. Instead, it waits for the state to fully change
-     * and gets the route information from there, @see _onStateChange
-     */
-    private _onDispatch;
-    /**
-     * To be called AFTER the state has been changed to populate the transaction with the current route.
-     */
-    private _onStateChange;
-    /** Creates final transaction context before confirmation */
-    private _prepareFinalContext;
-    /** Pushes a recent route key, and removes earlier routes when there is greater than the max length */
-    private _pushRecentRouteKey;
-    /** Cancels the latest transaction so it does not get sent to Sentry. */
-    private _discardLatestTransaction;
-    /**
-     *
-     */
-    private _clearStateChangeTimeout;
-}
-/**
- * Backwards compatibility alias for ReactNavigationInstrumentation
- * @deprecated Use ReactNavigationInstrumentation
- */
-export declare const ReactNavigationV5Instrumentation: typeof ReactNavigationInstrumentation;
-export declare const BLANK_TRANSACTION_CONTEXT: {
-    name: string;
-    op: string;
-    tags: {
-        'routing.instrumentation': string;
-    };
-    data: {};
+    registerNavigationContainer: (navigationContainerRef: unknown) => void;
 };
+export interface NavigationRoute {
+    name: string;
+    key: string;
+    params?: Record<string, any>;
+}
 export {};
 //# sourceMappingURL=reactnavigation.d.ts.map