@rejourneyco/react-native 1.0.7

package/lib/typescript/index.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Rejourney - Session Recording and Replay SDK for React Native
+ *
+ * Captures user interactions, gestures, and screen states for replay and analysis.
+ *
+ * Just call initRejourney() - everything else is automatic!
+ *
+ * Copyright (c) 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See LICENSE-APACHE for full terms.
+ *
+ * @example
+ * ```typescript
+ * import { initRejourney } from 'rejourney';
+ *
+ * // Initialize the SDK with your public key - that's it!
+ * initRejourney('pk_live_xxxxxxxxxxxx');
+ *
+ * // Or with options:
+ * initRejourney('pk_live_xxxxxxxxxxxx', { debug: true });
+ * ```
+ */
+import type { RejourneyConfig, RejourneyAPI } from './types';
+/**
+ * Main Rejourney API (Internal)
+ */
+declare const Rejourney: RejourneyAPI;
+/**
+ * Initialize Rejourney SDK - STEP 1 of 3
+ *
+ * This sets up the SDK, handles attestation, and prepares for recording,
+ * but does NOT start recording automatically. Call startRejourney() after
+ * obtaining user consent to begin recording.
+ *
+ * @param publicRouteKey - Your public route key from the Rejourney dashboard
+ * @param options - Optional configuration options
+ *
+ * @example
+ * ```typescript
+ * import { initRejourney, startRejourney } from 'rejourney';
+ *
+ * // Step 1: Initialize SDK (safe to call on app start)
+ * initRejourney('pk_live_xxxxxxxxxxxx');
+ *
+ * // Step 2: After obtaining user consent
+ * startRejourney();
+ *
+ * // With options
+ * initRejourney('pk_live_xxxxxxxxxxxx', {
+ *   debug: true,
+ *   apiUrl: 'https://api.yourdomain.com',
+ *   projectId: 'your-project-id',
+ * });
+ * ```
+ */
+export declare function initRejourney(publicRouteKey: string, options?: Omit<RejourneyConfig, 'publicRouteKey'>): void;
+/**
+ * Start recording - STEP 2 of 3 (call after user consent)
+ *
+ * Begins session recording. Call this after obtaining user consent for recording.
+ *
+ * @example
+ * ```typescript
+ * import { initRejourney, startRejourney } from 'rejourney';
+ *
+ * initRejourney('pk_live_xxxxxxxxxxxx');
+ *
+ * // After user accepts consent dialog
+ * startRejourney();
+ * ```
+ */
+export declare function startRejourney(): void;
+/**
+ * Stop recording and cleanup all resources.
+ *
+ * Note: This is usually not needed as the SDK handles cleanup automatically.
+ * Only call this if you want to explicitly stop recording.
+ */
+export declare function stopRejourney(): void;
+export default Rejourney;
+export * from './types';
+export { trackTap, trackScroll, trackGesture, trackInput, trackScreen, captureError, getSessionMetrics, } from './sdk/autoTracking';
+export { trackNavigationState, useNavigationTracking } from './sdk/autoTracking';
+export { LogLevel } from './sdk/utils';
+/**
+ * Configure SDK log verbosity.
+ *
+ * By default, the SDK logs minimally to avoid polluting your app's console:
+ * - Production/Release: SILENT (no logs at all)
+ * - Development/Debug: Only critical errors shown
+ *
+ * Essential lifecycle events (init success, session start/end) are automatically
+ * logged in debug builds only - you don't need to configure anything.
+ *
+ * Use this function only if you need to troubleshoot SDK behavior.
+ *
+ * @param level - Minimum log level to display
+ *
+ * @example
+ * ```typescript
+ * import { setLogLevel, LogLevel } from 'rejourney';
+ *
+ * // Enable verbose logging for SDK debugging (not recommended for regular use)
+ * setLogLevel(LogLevel.DEBUG);
+ *
+ * // Show warnings and errors (for troubleshooting)
+ * setLogLevel(LogLevel.WARNING);
+ *
+ * // Silence all logs (default behavior in production)
+ * setLogLevel(LogLevel.SILENT);
+ * ```
+ */
+export declare function setLogLevel(level: number): void;
+export { Mask } from './components/Mask';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/sdk/autoTracking.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Rejourney Auto Tracking Module
+ *
+ * Automatic tracking features that work with just init() - no additional code needed.
+ * This module handles:
+ * - Rage tap detection
+ * - Error tracking (JS + React Native)
+ * - Session metrics aggregation
+ * - Device info collection
+ * - Anonymous ID generation
+ * - Funnel/screen tracking
+ * - Score calculations
+ *
+ * IMPORTANT: This file uses lazy loading for react-native imports to avoid
+ * "PlatformConstants could not be found" errors on RN 0.81+.
+ */
+import type { DeviceInfo, ErrorEvent } from '../types';
+export interface TapEvent {
+    x: number;
+    y: number;
+    timestamp: number;
+    targetId?: string;
+}
+export interface SessionMetrics {
+    totalEvents: number;
+    touchCount: number;
+    scrollCount: number;
+    gestureCount: number;
+    inputCount: number;
+    navigationCount: number;
+    errorCount: number;
+    rageTapCount: number;
+    deadTapCount: number;
+    apiSuccessCount: number;
+    apiErrorCount: number;
+    apiTotalCount: number;
+    netTotalDurationMs: number;
+    netTotalBytes: number;
+    screensVisited: string[];
+    uniqueScreensCount: number;
+    interactionScore: number;
+    explorationScore: number;
+    uxScore: number;
+}
+export interface AutoTrackingConfig {
+    rageTapThreshold?: number;
+    rageTapTimeWindow?: number;
+    rageTapRadius?: number;
+    trackJSErrors?: boolean;
+    trackPromiseRejections?: boolean;
+    trackReactNativeErrors?: boolean;
+    collectDeviceInfo?: boolean;
+    maxSessionDurationMs?: number;
+    detectDeadTaps?: boolean;
+}
+/**
+ * Mark a tap as handled.
+ * No-op — kept for API compatibility. Dead tap detection is now native-side.
+ */
+export declare function markTapHandled(): void;
+/**
+ * Initialize auto tracking features
+ * Called automatically by Rejourney.init() - no user action needed
+ */
+export declare function initAutoTracking(trackingConfig: AutoTrackingConfig, callbacks?: {
+    onRageTap?: (count: number, x: number, y: number) => void;
+    onError?: (error: ErrorEvent) => void;
+    onScreen?: (screenName: string, previousScreen?: string) => void;
+}): void;
+/**
+ * Cleanup auto tracking features
+ */
+export declare function cleanupAutoTracking(): void;
+/**
+ * Track a tap event for rage tap detection
+ * Called automatically from touch interceptor
+ */
+export declare function trackTap(tap: TapEvent): void;
+/**
+ * Notify that a state change occurred (navigation, modal, etc.)
+ * Kept for API compatibility
+ */
+export declare function notifyStateChange(): void;
+/**
+ * Manually track an error (for API errors, etc.)
+ */
+export declare function captureError(message: string, stack?: string, name?: string): void;
+/**
+ * Track a navigation state change from React Navigation.
+ *
+ * For bare React Native apps using @react-navigation/native.
+ * Just add this to your NavigationContainer's onStateChange prop.
+ *
+ * @example
+ * ```tsx
+ * import { trackNavigationState } from 'rejourney';
+ *
+ * <NavigationContainer onStateChange={trackNavigationState}>
+ *   ...
+ * </NavigationContainer>
+ * ```
+ */
+export declare function trackNavigationState(state: any): void;
+/**
+ * React hook for navigation tracking.
+ *
+ * Returns props to spread on NavigationContainer that will:
+ * 1. Track the initial screen on mount (via onReady)
+ * 2. Track all subsequent navigations (via onStateChange)
+ *
+ * This is the RECOMMENDED approach for bare React Native apps.
+ *
+ * @example
+ * ```tsx
+ * import { useNavigationTracking } from 'rejourney';
+ * import { NavigationContainer } from '@react-navigation/native';
+ *
+ * function App() {
+ *   const navigationTracking = useNavigationTracking();
+ *
+ *   return (
+ *     <NavigationContainer {...navigationTracking}>
+ *       <RootNavigator />
+ *     </NavigationContainer>
+ *   );
+ * }
+ * ```
+ */
+export declare function useNavigationTracking(): {
+    ref: any;
+    onReady: any;
+    onStateChange: typeof trackNavigationState;
+};
+/**
+ * Track a screen view
+ * This updates JS metrics AND notifies the native module to send to backend
+ */
+export declare function trackScreen(screenName: string): void;
+/**
+ * Track an API request with timing data
+ */
+export declare function trackAPIRequest(success: boolean, _statusCode: number, durationMs?: number, responseBytes?: number): void;
+/**
+ * Track a scroll event
+ */
+export declare function trackScroll(): void;
+/**
+ * Track a gesture event
+ */
+export declare function trackGesture(): void;
+/**
+ * Track an input event (keyboard)
+ */
+export declare function trackInput(): void;
+/**
+ * Get current session metrics
+ */
+export declare function getSessionMetrics(): SessionMetrics & {
+    netAvgDurationMs: number;
+};
+/**
+ * Reset metrics for new session
+ */
+export declare function resetMetrics(): void;
+export declare function setMaxSessionDurationMinutes(minutes?: number): void;
+export declare function hasExceededMaxSessionDuration(): boolean;
+export declare function getRemainingSessionDurationMs(): number;
+/**
+ * Collect device information
+ */
+/**
+ * Collect device information
+ */
+export declare function collectDeviceInfo(): Promise<DeviceInfo>;
+/**
+ * Get the anonymous ID (synchronous - returns generated ID immediately)
+ */
+export declare function getAnonymousId(): string;
+/**
+ * Ensure a stable, persisted anonymous/device ID is available.
+ * Returns the stored ID if present, otherwise generates and persists one.
+ */
+export declare function ensurePersistentAnonymousId(): Promise<string>;
+/**
+ * Load anonymous ID from persistent storage
+ * Call this at app startup for best results
+ */
+export declare function loadAnonymousId(): Promise<string>;
+/**
+ * Set a custom anonymous ID
+ */
+export declare function setAnonymousId(id: string): void;
+declare const _default: {
+    init: typeof initAutoTracking;
+    cleanup: typeof cleanupAutoTracking;
+    trackTap: typeof trackTap;
+    trackScroll: typeof trackScroll;
+    trackGesture: typeof trackGesture;
+    trackInput: typeof trackInput;
+    trackScreen: typeof trackScreen;
+    trackAPIRequest: typeof trackAPIRequest;
+    captureError: typeof captureError;
+    getMetrics: typeof getSessionMetrics;
+    resetMetrics: typeof resetMetrics;
+    collectDeviceInfo: typeof collectDeviceInfo;
+    getAnonymousId: typeof getAnonymousId;
+    setAnonymousId: typeof setAnonymousId;
+    markTapHandled: typeof markTapHandled;
+};
+export default _default;
+//# sourceMappingURL=autoTracking.d.ts.map

package/lib/typescript/sdk/constants.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Rejourney SDK Constants
+ */
+import { SDK_VERSION } from './version';
+export { SDK_VERSION };
+/** Default configuration values */
+export declare const DEFAULT_CONFIG: {
+    readonly enabled: true;
+    readonly captureFPS: 0.5;
+    readonly captureOnEvents: true;
+    readonly maxSessionDuration: number;
+    readonly maxStorageSize: number;
+    readonly autoScreenTracking: true;
+    readonly autoGestureTracking: true;
+    readonly privacyOcclusion: true;
+    readonly enableCompression: true;
+    readonly inactivityThreshold: 5000;
+    readonly disableInDev: false;
+    readonly detectRageTaps: true;
+    readonly detectDeadTaps: true;
+    readonly rageTapThreshold: 3;
+    readonly rageTapTimeWindow: 1000;
+    readonly debug: false;
+    readonly autoStartRecording: true;
+    readonly collectDeviceInfo: true;
+    readonly collectGeoLocation: true;
+    readonly postNavigationDelay: 300;
+    readonly postGestureDelay: 200;
+    readonly postModalDelay: 400;
+};
+/** Event type constants */
+export declare const EVENT_TYPES: {
+    readonly GESTURE: "gesture";
+    readonly SCREEN_CHANGE: "screen_change";
+    readonly CUSTOM: "custom";
+    readonly APP_STATE: "app_state";
+    readonly FRUSTRATION: "frustration";
+    readonly ERROR: "error";
+};
+/** Gesture type constants */
+export declare const GESTURE_TYPES: {
+    readonly TAP: "tap";
+    readonly DOUBLE_TAP: "double_tap";
+    readonly LONG_PRESS: "long_press";
+    readonly SWIPE_LEFT: "swipe_left";
+    readonly SWIPE_RIGHT: "swipe_right";
+    readonly SWIPE_UP: "swipe_up";
+    readonly SWIPE_DOWN: "swipe_down";
+    readonly PINCH: "pinch";
+    readonly SCROLL: "scroll";
+    readonly RAGE_TAP: "rage_tap";
+    readonly DEAD_TAP: "dead_tap";
+};
+/** Playback speeds */
+export declare const PLAYBACK_SPEEDS: readonly [0.5, 1, 2, 4];
+/** Capture settings */
+export declare const CAPTURE_SETTINGS: {
+    readonly DEFAULT_FPS: 0.5;
+    readonly MIN_FPS: 0.1;
+    readonly MAX_FPS: 2;
+    readonly CAPTURE_SCALE: 0.25;
+    readonly MIN_CAPTURE_DELTA_TIME: 0.5;
+};
+/** Memory management settings */
+export declare const MEMORY_SETTINGS: {
+    /** Maximum events to keep in memory before flushing */
+    readonly MAX_EVENTS_IN_MEMORY: 100;
+    /** Memory warning threshold in MB (flush when exceeded) */
+    readonly MEMORY_WARNING_THRESHOLD_MB: 100;
+    /** Enable aggressive memory cleanup during low memory */
+    readonly AGGRESSIVE_CLEANUP_ENABLED: true;
+    /** Bitmap pool size for reusing bitmaps (Android) */
+    readonly BITMAP_POOL_SIZE: 3;
+};
+/** CPU throttling settings */
+export declare const CPU_SETTINGS: {
+    /** Throttle captures when CPU usage exceeds this percentage */
+    readonly CPU_THROTTLE_THRESHOLD: 80;
+    /** Minimum interval between captures when throttled (seconds) */
+    readonly THROTTLED_MIN_INTERVAL: 2;
+    /** Skip captures when battery is below this level (0-100) */
+    readonly LOW_BATTERY_THRESHOLD: 15;
+    /** Skip captures when device is thermally throttled */
+    readonly THERMAL_THROTTLE_ENABLED: true;
+    /** Maximum consecutive captures before forced cooldown */
+    readonly MAX_CONSECUTIVE_CAPTURES: 10;
+    /** Cooldown period after max consecutive captures (ms) */
+    readonly CAPTURE_COOLDOWN_MS: 1000;
+};
+/** Storage management settings */
+export declare const STORAGE_SETTINGS: {
+    /** Maximum total storage for session data (bytes) */
+    readonly MAX_STORAGE_SIZE: number;
+    /** Storage warning threshold - start cleanup at this level */
+    readonly STORAGE_WARNING_THRESHOLD: 0.8;
+    /** Number of old sessions to keep */
+    readonly MAX_SESSIONS_TO_KEEP: 5;
+    /** Auto-delete sessions older than this (hours) */
+    readonly SESSION_EXPIRY_HOURS: 24;
+    /** Use efficient binary storage format */
+    readonly USE_BINARY_FORMAT: true;
+};
+/** Network/Upload settings */
+export declare const UPLOAD_SETTINGS: {
+    /** Batch upload interval (ms) */
+    readonly BATCH_INTERVAL_MS: 30000;
+    /** Max retry attempts for failed uploads */
+    readonly MAX_RETRY_ATTEMPTS: 3;
+    /** Retry delay multiplier (exponential backoff) */
+    readonly RETRY_DELAY_MULTIPLIER: 2;
+    /** Initial retry delay (ms) */
+    readonly INITIAL_RETRY_DELAY_MS: 1000;
+    /** Max events per upload batch */
+    readonly MAX_EVENTS_PER_BATCH: 50;
+    /** Skip uploads when on cellular and battery is low */
+    readonly CELLULAR_BATTERY_AWARE: true;
+};
+/** Privacy constants */
+export declare const PRIVACY: {
+    readonly OCCLUSION_COLOR: "#808080";
+    readonly SENSITIVE_COMPONENT_TYPES: readonly ["TextInput", "SecureTextEntry", "PasswordField"];
+};
+//# sourceMappingURL=constants.d.ts.map

package/lib/typescript/sdk/errorTracking.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Error Tracking Module for Rejourney SDK
+ *
+ * Handles JS error capture, React Native ErrorUtils, and unhandled promise rejections.
+ * Split from autoTracking.ts for better code organization.
+ */
+import type { ErrorEvent } from '../types';
+/**
+ * Setup error tracking with the given callback
+ */
+export declare function setupErrorTracking(config: {
+    trackJSErrors?: boolean;
+    trackPromiseRejections?: boolean;
+    trackReactNativeErrors?: boolean;
+}, onError: (error: ErrorEvent) => void): void;
+/**
+ * Cleanup error tracking and restore original handlers
+ */
+export declare function cleanupErrorTracking(): void;
+/**
+ * Get current error count
+ */
+export declare function getErrorCount(): number;
+/**
+ * Reset error count
+ */
+export declare function resetErrorCount(): void;
+/**
+ * Manually capture an error
+ */
+export declare function captureError(message: string, stack?: string, name?: string): void;
+//# sourceMappingURL=errorTracking.d.ts.map

package/lib/typescript/sdk/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Rejourney SDK
+ * Session recording and replay for React Native
+ */
+export * from './constants';
+export * from './utils';
+export * from './autoTracking';
+export * from './networkInterceptor';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/sdk/metricsTracking.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Session Metrics Module for Rejourney SDK
+ *
+ * Tracks and calculates session metrics including interaction scores,
+ * API performance, and user engagement metrics.
+ * Split from autoTracking.ts for better code organization.
+ */
+/**
+ * Session metrics structure
+ */
+export interface SessionMetrics {
+    totalEvents: number;
+    touchCount: number;
+    scrollCount: number;
+    gestureCount: number;
+    inputCount: number;
+    navigationCount: number;
+    errorCount: number;
+    rageTapCount: number;
+    deadTapCount: number;
+    apiSuccessCount: number;
+    apiErrorCount: number;
+    apiTotalCount: number;
+    netTotalDurationMs: number;
+    netTotalBytes: number;
+    screensVisited: string[];
+    uniqueScreensCount: number;
+    interactionScore: number;
+    explorationScore: number;
+    uxScore: number;
+}
+/**
+ * Create empty metrics object
+ */
+export declare function createEmptyMetrics(): SessionMetrics;
+/**
+ * Reset all metrics
+ */
+export declare function resetMetrics(): void;
+/**
+ * Initialize metrics for new session
+ */
+export declare function initMetrics(): void;
+/**
+ * Get current session metrics with calculated scores
+ */
+export declare function getSessionMetrics(): SessionMetrics;
+/**
+ * Set max session duration (in minutes)
+ */
+export declare function setMaxSessionDurationMinutes(minutes?: number): void;
+export declare function incrementTouchCount(): void;
+export declare function incrementScrollCount(): void;
+export declare function incrementNavigationCount(): void;
+export declare function incrementRageTapCount(): void;
+export declare function incrementDeadTapCount(): void;
+export declare function incrementErrorCount(): void;
+export declare function addScreenVisited(screenName: string): void;
+export declare function trackAPIMetrics(success: boolean, durationMs?: number, responseBytes?: number): void;
+//# sourceMappingURL=metricsTracking.d.ts.map

package/lib/typescript/sdk/navigation.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright 2026 Rejourney
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Rejourney Navigation Utilities
+ *
+ * Helper functions for extracting human-readable screen names from
+ * React Navigation / Expo Router state.
+ *
+ * These functions are used internally by the SDK's automatic navigation
+ * detection. You don't need to import or use these directly.
+ */
+/**
+ * Normalize a screen name to be human-readable
+ * Handles common patterns from React Native / Expo Router
+ *
+ * @param raw - Raw screen name to normalize
+ * @returns Cleaned, human-readable screen name
+ */
+export declare function normalizeScreenName(raw: string): string;
+/**
+ * Get a human-readable screen name from Expo Router path and segments
+ *
+ * @param pathname - The current route pathname
+ * @param segments - Route segments from useSegments()
+ * @returns Human-readable screen name
+ */
+export declare function getScreenNameFromPath(pathname: string, segments: string[]): string;
+/**
+ * Get the current route name from a navigation state object
+ *
+ * @param state - React Navigation state object
+ * @returns Current route name or null
+ */
+export declare function getCurrentRouteFromState(state: any): string | null;
+//# sourceMappingURL=navigation.d.ts.map