@stripe/stripe-react-native 0.58.0 → 0.59.0

package/android/src/main/java/com/reactnativestripesdk/StripeConnectDeepLinkInterceptorActivity.kt

@@ -0,0 +1,77 @@
+package com.reactnativestripesdk
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import android.util.Log
+
+/**
+ * Transparent interceptor Activity that captures stripe-connect:// deep links
+ * before they reach React Native's Linking module.
+ *
+ * This prevents Expo Router from receiving the URL and dismissing the current screen.
+ * The URL is stored in StripeSdkModule's internal storage and retrieved via polling.
+ *
+ * HOW IT WORKS:
+ * 1. Android launches this Activity when a stripe-connect:// URL is opened
+ * 2. onCreate() extracts the URL and stores it via StripeSdkModule.storeStripeConnectDeepLink()
+ * 3. Launches an Intent to bring the main app to the foreground
+ * 4. The Activity immediately finishes without showing any UI
+ * 5. JavaScript polls for URLs via NativeStripeSdk.pollAndClearPendingStripeConnectUrls()
+ *
+ * MANIFEST CONFIGURATION:
+ * The AndroidManifest.xml declares this Activity with:
+ * - android:exported="true" - allows deep links from outside the app
+ * - android:launchMode="singleTask" - reuses existing instance if available
+ * - android:theme="@android:style/Theme.Translucent.NoTitleBar" - transparent UI
+ * - Intent filter for stripe-connect:// scheme
+ *
+ * USER IMPACT:
+ * - Zero configuration required by users
+ * - Works automatically for all package names
+ * - No MainActivity override needed
+ */
+class StripeConnectDeepLinkInterceptorActivity : Activity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    // Extract the deep link URL from the Intent
+    val url = intent?.data?.toString()
+
+    if (url != null && url.startsWith("stripe-connect://")) {
+      // Store in SDK's internal storage (thread-safe)
+      StripeSdkModule.storeStripeConnectDeepLink(url)
+    } else {
+      Log.w(TAG, "Unexpected URL scheme in StripeConnectDeepLinkInterceptor: $url")
+    }
+
+    // Bring the main app back to the foreground
+    // This is critical because when Custom Tabs opens a deep link,
+    // the interceptor Activity starts in a new task. When it finishes,
+    // Android doesn't automatically return to the main app - it just shows
+    // the Custom Tab again. We need to explicitly bring the app forward.
+    try {
+      val packageName = applicationContext.packageName
+      val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
+
+      if (launchIntent != null) {
+        // Flags to bring existing task to front without recreating activities
+        launchIntent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
+        launchIntent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+        startActivity(launchIntent)
+      } else {
+        Log.w(TAG, "Could not get launch intent for package: $packageName")
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Error bringing app to foreground", e)
+    }
+
+    // Immediately finish - don't show any UI
+    // This makes the Activity transparent to the user
+    finish()
+  }
+
+  companion object {
+    private const val TAG = "StripeConnectInterceptor"
+  }
+}

package/android/src/main/java/com/reactnativestripesdk/StripeSdkModule.kt

@@ -5,9 +5,13 @@ import android.app.Activity
 import android.app.Application
 import android.content.Intent
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
 import android.view.ViewGroup
+import androidx.appcompat.app.AppCompatActivity
 import androidx.browser.customtabs.CustomTabsIntent
+import androidx.core.net.toUri
 import androidx.fragment.app.FragmentActivity
 import com.facebook.react.ReactActivity
 import com.facebook.react.bridge.Arguments
@@ -19,6 +23,7 @@ import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.module.annotations.ReactModule
 import com.reactnativestripesdk.addresssheet.AddressLauncherManager
 import com.reactnativestripesdk.customersheet.CustomerSheetManager
@@ -63,6 +68,7 @@ import com.stripe.android.model.ConfirmPaymentIntentParams
 import com.stripe.android.model.ConfirmSetupIntentParams
 import com.stripe.android.model.PaymentIntent
 import com.stripe.android.model.PaymentMethod
+import com.stripe.android.model.RadarSession
 import com.stripe.android.model.SetupIntent
 import com.stripe.android.model.Token
 import com.stripe.android.payments.bankaccount.CollectBankAccountConfiguration
@@ -106,6 +112,10 @@ class StripeSdkModule(
 
   internal var composeCompatView: StripeAbstractComposeView.CompatView? = null
 
+  // Storage for pending stripe-connect:// deep link URLs to prevent Expo Router from receiving them
+  private val pendingStripeConnectUrls = mutableListOf<String>()
+  private val pendingUrlsLock = Any()
+
   val eventEmitter: EventEmitterCompat by lazy { EventEmitterCompat(reactApplicationContext) }
 
   private val mActivityEventListener =
@@ -128,11 +138,6 @@ class StripeSdkModule(
                   it,
                 )
                 createPlatformPayPaymentMethodPromise = null
-              } ?: run {
-                Log.d(
-                  "StripeReactNative",
-                  "No promise was found, Google Pay result went unhandled,",
-                )
               }
             }
           }
@@ -179,14 +184,38 @@ class StripeSdkModule(
   }
 
   @SuppressLint("RestrictedApi")
-  override fun getTypedExportedConstants() =
-    mapOf(
+  override fun getTypedExportedConstants(): Map<String, Any> {
+    val packageInfo =
+      try {
+        reactApplicationContext.packageManager.getPackageInfo(
+          reactApplicationContext.packageName,
+          0,
+        )
+      } catch (e: Exception) {
+        null
+      }
+
+    return mapOf(
       "API_VERSIONS" to
         mapOf(
           "CORE" to ApiVersion.API_VERSION_CODE,
           "ISSUING" to PushProvisioningProxy.getApiVersion(),
         ),
+      "SYSTEM_INFO" to
+        mapOf(
+          "sdkVersion" to STRIPE_ANDROID_SDK_VERSION,
+          "osVersion" to android.os.Build.VERSION.RELEASE,
+          "deviceType" to "${android.os.Build.MANUFACTURER} ${android.os.Build.MODEL}",
+          "appName" to (
+            reactApplicationContext.applicationInfo
+              .loadLabel(
+                reactApplicationContext.packageManager,
+              ).toString()
+          ),
+          "appVersion" to (packageInfo?.versionName ?: ""),
+        ),
     )
+  }
 
   @ReactMethod
   override fun initialise(
@@ -1300,6 +1329,31 @@ class StripeSdkModule(
     }
   }
 
+  @ReactMethod
+  override fun createRadarSession(promise: Promise) {
+    if (!::stripe.isInitialized) {
+      promise.resolve(createMissingInitError())
+      return
+    }
+
+    stripe.createRadarSession(
+      stripeAccountId = stripeAccountId,
+      callback =
+        object : com.stripe.android.ApiResultCallback<RadarSession> {
+          override fun onSuccess(session: RadarSession) {
+            val result = WritableNativeMap()
+            result.putString("id", session.id)
+            promise.resolve(result)
+          }
+
+          override fun onError(e: Exception) {
+            promise.resolve(createError(ErrorType.Failed.toString(), e))
+          }
+        },
+      activity = getCurrentActivityOrResolveWithError(promise) as? AppCompatActivity,
+    )
+  }
+
   @ReactMethod
   override fun createEmbeddedPaymentElement(
     intentConfig: ReadableMap,
@@ -1347,11 +1401,12 @@ class StripeSdkModule(
     url: String,
     promise: Promise,
   ) {
+    isAuthWebViewActive = true
     val activity = getCurrentActivityOrResolveWithError(promise) ?: return
 
     UiThreadUtil.runOnUiThread {
       try {
-        val uri = android.net.Uri.parse(url)
+        val uri = url.toUri()
         val builder =
           androidx.browser.customtabs.CustomTabsIntent
             .Builder()
@@ -1362,18 +1417,214 @@ class StripeSdkModule(
 
         val customTabsIntent = builder.build()
 
+        // NOTE: We intentionally do NOT use FLAG_ACTIVITY_NO_HISTORY here.
+        // That flag can cause React Native's state restoration to fail when returning from Custom Tabs,
+        // resulting in the navigation stack being reset and the previous screen being dismissed.
+        // Custom Tabs will be properly cleaned up when the user navigates back or the session completes.
+
         // Note: Custom Tabs doesn't have built-in redirect handling like iOS ASWebAuthenticationSession.
         // The redirect will be handled via deep linking when the auth server redirects to stripe-connect://
         // The React Native Linking module will capture the deep link and pass it back to the JS layer.
         customTabsIntent.launchUrl(activity, uri)
 
+        // Fallback: Reset after timeout if JavaScript doesn't call authWebViewDeepLinkHandled
+        Handler(Looper.getMainLooper()).postDelayed({
+          if (isAuthWebViewActive) {
+            isAuthWebViewActive = false
+          }
+        }, AUTH_WEBVIEW_FALLBACK_TIMEOUT_MS)
+
         promise.resolve(null)
       } catch (e: Exception) {
+        isAuthWebViewActive = false
         promise.resolve(createError("Failed", e))
       }
     }
   }
 
+  @ReactMethod
+  override fun downloadAndShareFile(
+    url: String,
+    filename: String?,
+    promise: Promise,
+  ) {
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        // Download file
+        val client = okhttp3.OkHttpClient()
+        val request =
+          okhttp3.Request
+            .Builder()
+            .url(url)
+            .build()
+        val response = client.newCall(request).execute()
+
+        if (!response.isSuccessful) {
+          promise.resolve(
+            Arguments.createMap().apply {
+              putBoolean("success", false)
+              putString("error", "NetworkError")
+              putString("message", "HTTP ${response.code}")
+            },
+          )
+          return@launch
+        }
+
+        // Save to cache directory
+        val exportsDir = java.io.File(reactApplicationContext.cacheDir, "stripe-exports")
+        exportsDir.mkdirs()
+
+        val file = java.io.File(exportsDir, "export-${java.util.UUID.randomUUID()}.csv")
+
+        response.body?.byteStream()?.use { input ->
+          file.outputStream().use { output ->
+            input.copyTo(output)
+          }
+        }
+
+        // Share on main thread
+        UiThreadUtil.runOnUiThread {
+          shareFile(file, promise)
+        }
+      } catch (e: Exception) {
+        promise.resolve(
+          Arguments.createMap().apply {
+            putBoolean("success", false)
+            putString("error", "DownloadFailed")
+            putString("message", e.message ?: "Unknown error")
+          },
+        )
+      }
+    }
+  }
+
+  private fun shareFile(
+    file: java.io.File,
+    promise: Promise,
+  ) {
+    val activity = reactApplicationContext.getCurrentActivity()
+    if (activity == null) {
+      promise.resolve(
+        Arguments.createMap().apply {
+          putBoolean("success", false)
+          putString("error", "NoActivity")
+          putString("message", "No activity available")
+        },
+      )
+      return
+    }
+
+    try {
+      val uri =
+        androidx.core.content.FileProvider.getUriForFile(
+          reactApplicationContext,
+          "${reactApplicationContext.packageName}.stripe.fileprovider",
+          file,
+        )
+
+      val shareIntent =
+        Intent(Intent.ACTION_SEND).apply {
+          type = "text/csv"
+          putExtra(Intent.EXTRA_STREAM, uri)
+          addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+        }
+
+      val chooser = Intent.createChooser(shareIntent, "Share CSV Export")
+      activity.startActivity(chooser)
+
+      // Schedule cleanup
+      android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+        file.delete()
+      }, 3000)
+
+      promise.resolve(
+        Arguments.createMap().apply {
+          putBoolean("success", true)
+        },
+      )
+    } catch (e: Exception) {
+      promise.resolve(
+        Arguments.createMap().apply {
+          putBoolean("success", false)
+          putString("error", "ShareFailed")
+          putString("message", e.message ?: "Unknown error")
+        },
+      )
+    }
+  }
+
+  @ReactMethod
+  override fun authWebViewDeepLinkHandled(
+    id: String,
+    promise: Promise,
+  ) {
+    isAuthWebViewActive = false
+    promise.resolve(null)
+  }
+
+  /**
+   * Store a stripe-connect:// deep link URL for later retrieval.
+   * This prevents the URL from being broadcast to Expo Router.
+   */
+  @ReactMethod
+  override fun storeStripeConnectDeepLink(
+    url: String,
+    promise: Promise,
+  ) {
+    synchronized(pendingUrlsLock) {
+      pendingStripeConnectUrls.add(url)
+    }
+    promise.resolve(null)
+  }
+
+  /**
+   * Poll for pending stripe-connect:// deep link URLs.
+   * Returns all pending URLs and clears the queue.
+   *
+   * URLs are captured by StripeConnectDeepLinkInterceptor Activity, which prevents
+   * Expo Router from receiving the URLs and dismissing the current screen.
+   */
+  @ReactMethod
+  override fun pollAndClearPendingStripeConnectUrls(promise: Promise) {
+    try {
+      val urlsArray = Arguments.createArray()
+
+      // Get URLs from SDK's internal storage (set by StripeConnectDeepLinkInterceptor)
+      val sdkUrls = retrieveAndClearPendingUrls()
+      sdkUrls.forEach { url ->
+        urlsArray.pushString(url)
+      }
+
+      // Legacy: Support old MainActivity pattern (deprecated, will be removed in future version)
+      // This maintains backward compatibility for apps that implemented the manual pattern
+      try {
+        val mainActivityClass = Class.forName("com.stripe.examplestripeconnect.MainActivity")
+        val getPendingUrlsMethod = mainActivityClass.getMethod("getPendingUrls")
+
+        @Suppress("UNCHECKED_CAST")
+        val mainActivityUrls = getPendingUrlsMethod.invoke(null) as? List<String>
+        if (!mainActivityUrls.isNullOrEmpty()) {
+          Log.w(
+            TAG,
+            "Using deprecated MainActivity.getPendingUrls() pattern. " +
+              "This pattern is no longer needed and will be removed in a future version. " +
+              "The SDK now handles stripe-connect:// URLs automatically.",
+          )
+          mainActivityUrls.forEach { url ->
+            urlsArray.pushString(url)
+          }
+        }
+      } catch (e: Exception) {
+        // Expected when not using deprecated pattern - this is fine
+      }
+
+      promise.resolve(urlsArray)
+    } catch (e: Exception) {
+      Log.e(TAG, "Error polling URLs", e)
+      promise.reject("PollError", "Failed to poll pending Stripe Connect URLs: ${e.message}", e)
+    }
+  }
+
   override fun addListener(eventType: String?) {
     // noop, iOS only
   }
@@ -1429,40 +1680,49 @@ class StripeSdkModule(
   }
 
   private var isRecreatingReactActivity = false
+  private var isAuthWebViewActive = false
   private val activityLifecycleCallbacks =
     object : Application.ActivityLifecycleCallbacks {
       override fun onActivityCreated(
         activity: Activity,
         bundle: Bundle?,
       ) {
-        if (activity is ReactActivity) {
+        // Only set flag when ReactActivity is actually being recreated (bundle != null)
+        // bundle != null means this is a recreation, not first creation
+        if (activity is ReactActivity && bundle != null) {
           isRecreatingReactActivity = true
         }
-        if (isRecreatingReactActivity && activity.javaClass.name.startsWith("com.stripe.android")) {
+
+        // Don't finish Stripe activities during auth webview flow to prevent dismissing the previous screen
+        val isStripeActivity = activity.javaClass.name.startsWith("com.stripe.android")
+        val shouldFinish = isRecreatingReactActivity && isStripeActivity && !isAuthWebViewActive
+
+        if (shouldFinish) {
           activity.finish()
         }
-      }
 
-      override fun onActivityStarted(activity: Activity) {
+        // Reset flag after finishing Stripe activities
+        if (isRecreatingReactActivity && shouldFinish) {
+          Handler(Looper.getMainLooper()).post {
+            isRecreatingReactActivity = false
+          }
+        }
       }
 
-      override fun onActivityResumed(activity: Activity) {
-      }
+      override fun onActivityStarted(activity: Activity) {}
 
-      override fun onActivityPaused(activity: Activity) {
-      }
+      override fun onActivityResumed(activity: Activity) {}
 
-      override fun onActivityStopped(activity: Activity) {
-      }
+      override fun onActivityPaused(activity: Activity) {}
+
+      override fun onActivityStopped(activity: Activity) {}
 
       override fun onActivitySaveInstanceState(
         activity: Activity,
         bundle: Bundle,
-      ) {
-      }
+      ) {}
 
-      override fun onActivityDestroyed(activity: Activity) {
-      }
+      override fun onActivityDestroyed(activity: Activity) {}
     }
 
   /**
@@ -1491,5 +1751,48 @@ class StripeSdkModule(
 
   companion object {
     const val NAME = NativeStripeSdkModuleSpec.NAME
+    private const val TAG = "StripeSdkModule"
+
+    // Read the Stripe Android SDK version from gradle.properties at build time
+    private val STRIPE_ANDROID_SDK_VERSION = BuildConfig.STRIPE_ANDROID_SDK_VERSION
+
+    // Timeout for auth webview fallback (if JavaScript doesn't call authWebViewDeepLinkHandled)
+    private const val AUTH_WEBVIEW_FALLBACK_TIMEOUT_MS = 60_000L
+
+    // SDK-managed storage for pending stripe-connect:// URLs
+    // This is static because deep links can arrive before ReactContext is available
+    private val pendingConnectUrls = mutableListOf<String>()
+    private val urlsLock = Any()
+
+    /**
+     * Store a stripe-connect:// deep link URL.
+     * Called automatically by StripeConnectDeepLinkInterceptor.
+     * Can also be called manually from MainActivity if users implement custom handling.
+     *
+     * This method is thread-safe and can be called from any thread.
+     *
+     * @param url The stripe-connect:// URL to store
+     */
+    @JvmStatic
+    fun storeStripeConnectDeepLink(url: String) {
+      synchronized(urlsLock) {
+        pendingConnectUrls.add(url)
+      }
+    }
+
+    /**
+     * Retrieve and clear pending URLs.
+     * Internal method used by pollAndClearPendingStripeConnectUrls() bridge method.
+     *
+     * @return List of pending stripe-connect:// URLs
+     */
+    @JvmStatic
+    internal fun retrieveAndClearPendingUrls(): List<String> {
+      synchronized(urlsLock) {
+        val urls = pendingConnectUrls.toList()
+        pendingConnectUrls.clear()
+        return urls
+      }
+    }
   }
 }

package/android/src/main/java/com/reactnativestripesdk/StripeSdkPackage.kt

@@ -60,6 +60,7 @@ class StripeSdkPackage : BaseReactPackage() {
       AddressSheetViewManager(),
       EmbeddedPaymentElementViewManager(),
       NavigationBarManager(),
+      PaymentMethodMessagingElementViewManager(),
     )
 
   private fun getOnrampModuleClass(): Class<out NativeModule?> {

package/android/src/main/java/com/reactnativestripesdk/customersheet/CustomerSheetManager.kt

@@ -64,6 +64,8 @@ class CustomerSheetManager(
     val billingConfigParams = arguments.getMap("billingDetailsCollectionConfiguration")
     val allowsRemovalOfLastSavedPaymentMethod =
       arguments.getBooleanOr("allowsRemovalOfLastSavedPaymentMethod", true)
+    val opensCardScannerAutomatically =
+      arguments.getBooleanOr("opensCardScannerAutomatically", false)
     val paymentMethodOrder = arguments.getStringList("paymentMethodOrder")
 
     val appearance =
@@ -83,6 +85,7 @@ class CustomerSheetManager(
         .preferredNetworks(
           mapToPreferredNetworks(arguments.getIntegerList("preferredNetworks")),
         ).allowsRemovalOfLastSavedPaymentMethod(allowsRemovalOfLastSavedPaymentMethod)
+        .opensCardScannerAutomatically(opensCardScannerAutomatically)
         .cardBrandAcceptance(mapToCardBrandAcceptance(arguments))
 
     paymentMethodOrder?.let { configuration.paymentMethodOrder(it) }

package/android/src/main/java/com/reactnativestripesdk/utils/Errors.kt

@@ -58,6 +58,14 @@ class PaymentSheetException(
   message: String,
 ) : Exception(message)
 
+class PaymentMethodMessagingElementAppearanceException(
+  message: String,
+) : Exception(message)
+
+class PaymentMethodMessagingElementConfigurationException(
+  message: String,
+) : Exception(message)
+
 internal fun mapError(
   code: String,
   message: String?,

package/android/src/main/res/xml/file_paths.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+    <cache-path name="stripe_exports" path="stripe-exports/" />
+</paths>

package/android/src/oldarch/java/com/facebook/react/viewmanagers/PaymentMethodMessagingElementViewManagerDelegate.java

@@ -0,0 +1,36 @@
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* @generated by codegen project: GeneratePropsJavaDelegate.js
+*/
+
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.DynamicFromObject;
+import com.facebook.react.uimanager.BaseViewManager;
+import com.facebook.react.uimanager.BaseViewManagerDelegate;
+import com.facebook.react.uimanager.LayoutShadowNode;
+
+public class PaymentMethodMessagingElementViewManagerDelegate<T extends View, U extends BaseViewManager<T, ? extends LayoutShadowNode> & PaymentMethodMessagingElementViewManagerInterface<T>> extends BaseViewManagerDelegate<T, U> {
+  public PaymentMethodMessagingElementViewManagerDelegate(U viewManager) {
+    super(viewManager);
+  }
+  @Override
+  public void setProperty(T view, String propName, @Nullable Object value) {
+    switch (propName) {
+      case "appearance":
+        mViewManager.setAppearance(view, new DynamicFromObject(value));
+        break;
+      case "configuration":
+        mViewManager.setConfiguration(view, new DynamicFromObject(value));
+        break;
+      default:
+        super.setProperty(view, propName, value);
+    }
+  }
+}

package/android/src/oldarch/java/com/facebook/react/viewmanagers/PaymentMethodMessagingElementViewManagerInterface.java

@@ -0,0 +1,18 @@
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* @generated by codegen project: GeneratePropsJavaInterface.js
+*/
+
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import com.facebook.react.bridge.Dynamic;
+
+public interface PaymentMethodMessagingElementViewManagerInterface<T extends View>  {
+  void setAppearance(T view, Dynamic value);
+  void setConfiguration(T view, Dynamic value);
+}

package/android/src/oldarch/java/com/reactnativestripesdk/NativeStripeSdkModuleSpec.java

@@ -272,6 +272,22 @@ public abstract class NativeStripeSdkModuleSpec extends ReactContextBaseJavaModu
   @DoNotStrip
   public abstract void openAuthenticatedWebView(String id, String url, Promise promise);
 
+  @ReactMethod
+  @DoNotStrip
+  public abstract void downloadAndShareFile(String url, @Nullable String filename, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void authWebViewDeepLinkHandled(String id, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void storeStripeConnectDeepLink(String url, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void pollAndClearPendingStripeConnectUrls(Promise promise);
+
   @ReactMethod
   @DoNotStrip
   public abstract void addListener(String eventType);
@@ -279,4 +295,8 @@ public abstract class NativeStripeSdkModuleSpec extends ReactContextBaseJavaModu
   @ReactMethod
   @DoNotStrip
   public abstract void removeListeners(double count);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void createRadarSession(Promise promise);
 }