@juspay-tech/react-native-hyperswitch 0.2.1

package/android/src/main/java/io/hyperswitch/logs/LogData.kt

@@ -0,0 +1,159 @@
+package io.hyperswitch.logs
+
+import org.json.JSONException
+import org.json.JSONObject
+
+enum class LogType {
+  DEBUG, INFO, ERROR, WARNING
+}
+
+enum class LogCategory {
+  API, USER_ERROR, USER_EVENT, MERCHANT_EVENT, OTA_LIFE_CYCLE
+}
+
+enum class EventName {
+  HYPER_OTA_INIT, HYPER_OTA_FINISH, HYPER_OTA_EVENT, CRASH_EVENT
+}
+
+data class HSLog(
+  val timestamp: String,
+  val logType: LogType,
+  val component: String = "MOBILE",
+  val category: LogCategory,
+  val version: String,
+  var codePushVersion: String,
+  var clientCoreVersion: String,
+  val value: String,
+  val internalMetadata: String,
+  val sessionId: String,
+  var merchantId: String,
+  val paymentId: String,
+  val appId: String? = null,
+  val platform: String = "ANDROID",
+  val userAgent: String,
+  val eventName: EventName,
+  val latency: String? = null,
+  val firstEvent: Boolean = false,
+  val paymentMethod: String? = null,
+  val paymentExperience: String? = null,
+  val source: String
+) {
+  fun toJson(): String {
+    try {
+
+      val logData = JSONObject().apply {
+        put("timestamp", timestamp)
+        put("log_type", logType.name)
+        put("component", component)
+        put("category", category.toString())
+        put("version", version)
+        put("code_push_version", codePushVersion)
+        put("client_core_version", clientCoreVersion)
+        put("value", value)
+        put("internal_metadata", internalMetadata)
+        put("session_id", sessionId)
+        put("merchant_id", merchantId)
+        put("payment_id", paymentId)
+        put("app_id", appId ?: "")
+        put("platform", platform)
+        put("user_agent", userAgent)
+        put("event_name", eventName.name)
+        put("first_event", firstEvent.toString())
+        put("payment_method", paymentMethod ?: "")
+        put("payment_experience", paymentExperience ?: "")
+        put("latency", latency ?: "")
+        put("source", source)
+      }
+
+      val jsonString = logData.toString()
+      return jsonString
+    } catch (e: JSONException) {
+      return ""
+    }
+  }
+
+
+  class LogBuilder {
+    private var timestamp: String = System.currentTimeMillis().toString()
+    private var logType: LogType = LogType.INFO
+    private var component: String = "MOBILE"
+    private lateinit var category: LogCategory
+    private var version: String = ""
+    private var codePushVersion: String = ""
+    private var clientCoreVersion: String = ""
+    private var value: String = ""
+    private var internalMetadata: String = ""
+    private var sessionId: String = ""
+    private var merchantId: String = ""
+    private var paymentId: String = ""
+    private var appId: String? = null
+    private var platform: String = "ANDROID"
+    private var userAgent: String = ""
+    private lateinit var eventName: EventName
+    private var latency: String? = null
+    private var firstEvent: Boolean = false
+    private var paymentMethod: String? = null
+    private var paymentExperience: String? = null
+    private var source: String = ""
+
+    fun timestamp(timestamp: String) = apply { this.timestamp = timestamp }
+    fun logType(logType: String) = apply {
+      this.logType =
+        LogType.entries.find { it.name == logType.uppercase() } ?: LogType.INFO
+    }
+
+    fun component(component: String) = apply { this.component = component }
+    fun category(category: LogCategory) = apply { this.category = category }
+    fun version(version: String) = apply { this.version = version }
+    fun codePushVersion(codePushVersion: String) =
+      apply { this.codePushVersion = codePushVersion }
+
+    fun clientCoreVersion(clientCoreVersion: String) =
+      apply { this.clientCoreVersion = clientCoreVersion }
+
+    fun value(value: String) = apply { this.value = value }
+    fun internalMetadata(internalMetadata: String) =
+      apply { this.internalMetadata = internalMetadata }
+
+    fun sessionId(sessionId: String) = apply { this.sessionId = sessionId }
+    fun merchantId(merchantId: String) = apply { this.merchantId = merchantId }
+    fun paymentId(paymentId: String) = apply { this.paymentId = paymentId }
+    fun appId(appId: String?) = apply { this.appId = appId }
+    fun platform(platform: String) = apply { this.platform = platform }
+    fun userAgent(userAgent: String) = apply { this.userAgent = userAgent }
+    fun eventName(eventName: EventName) = apply { this.eventName = eventName }
+    fun latency(latency: String?) = apply { this.latency = latency }
+    fun firstEvent(firstEvent: Boolean) = apply { this.firstEvent = firstEvent }
+    fun paymentMethod(paymentMethod: String?) = apply { this.paymentMethod = paymentMethod }
+    fun paymentExperience(paymentExperience: String?) =
+      apply { this.paymentExperience = paymentExperience }
+
+    fun source(source: String) = apply { this.source = source }
+
+    fun build(): HSLog {
+      return HSLog(
+        timestamp,
+        logType,
+        component,
+        category,
+        version,
+        codePushVersion,
+        clientCoreVersion,
+        value,
+        internalMetadata,
+        sessionId,
+        merchantId,
+        paymentId,
+        appId,
+        platform,
+        userAgent,
+        eventName,
+        latency,
+        firstEvent,
+        paymentMethod,
+        paymentExperience,
+        source
+      )
+    }
+  }
+}

package/android/src/main/java/io/hyperswitch/logs/LogFileManager.kt

@@ -0,0 +1,60 @@
+package io.hyperswitch.logs
+
+import android.content.Context
+import org.json.JSONArray
+import org.json.JSONException
+import java.io.File
+import java.io.IOException
+
+class LogFileManager(private val context: Context) {
+
+  private val crashLogFileName = "crash_logs.json"
+  fun addLog(log: String) {
+    try {
+      val existingLogs = getAllLogs()
+      val newLogsArray = JSONArray(log)
+      for (i in 0 until newLogsArray.length()) {
+        existingLogs.put(newLogsArray.get(i))
+      }
+      writeLogsToFile(existingLogs)
+    } catch (e: JSONException) {
+      e.printStackTrace()
+    }
+  }
+
+  fun getAllLogs(): JSONArray {
+    return try {
+      val file = File(context.filesDir, crashLogFileName)
+      if (file.exists()) {
+        val content = file.readText()
+        JSONArray(content)
+      } else {
+        JSONArray()
+      }
+    } catch (e: JSONException) {
+      JSONArray()
+    } catch (e: IOException) {
+      JSONArray()
+    }
+  }
+
+  private fun writeLogsToFile(logs: JSONArray) {
+    try {
+      val file = File(context.filesDir, crashLogFileName)
+      file.writeText(logs.toString()) // Write the logs as a JSON string
+    } catch (e: IOException) {
+      e.printStackTrace()
+    }
+  }
+
+  fun clearFile() {
+    try {
+      val file = File(context.filesDir, "crash_logs.json")
+      if (file.exists()) {
+        file.delete()
+      }
+    } catch (e: IOException) {
+      e.printStackTrace()
+    }
+  }
+}

package/android/src/main/java/io/hyperswitch/networking/HyperNetworking.kt

@@ -0,0 +1,73 @@
+package io.hyperswitch.networking
+
+import okhttp3.*
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.RequestBody.Companion.toRequestBody
+import java.io.IOException
+
+object HyperNetworking {
+  private val client = OkHttpClient.Builder()
+    .connectTimeout(15, java.util.concurrent.TimeUnit.SECONDS)
+    .readTimeout(15, java.util.concurrent.TimeUnit.SECONDS)
+    .writeTimeout(15, java.util.concurrent.TimeUnit.SECONDS)
+    .build()
+
+  private fun makeHttpRequest(
+    urlString: String,
+    method: String,
+    headers: Map<String, String> = emptyMap(),
+    body: String? = null,
+    callback: (Result<String>) -> Unit
+  ) {
+    try {
+      val mediaType = "application/json".toMediaType()
+      val requestBody = body?.takeIf { it.isNotBlank() }?.toRequestBody(mediaType)
+
+      val url = try {
+        urlString.toHttpUrl()
+      } catch (e: Exception) {
+        callback(Result.failure(IllegalArgumentException("Invalid URL: $urlString", e)))
+        return
+      }
+
+      val requestBuilder = Request.Builder()
+        .url(url)
+        .method(method, requestBody)
+
+      headers.forEach { (key, value) ->
+        requestBuilder.addHeader(key, value)
+      }
+
+      val request = requestBuilder.build()
+      client.newCall(request).enqueue(object : Callback {
+        override fun onFailure(call: Call, e: IOException) {
+          callback(Result.failure(IOException("Network error: ${e.localizedMessage}", e)))
+        }
+
+        override fun onResponse(call: Call, response: Response) {
+          response.use {
+            when {
+              it.isSuccessful -> callback(Result.success(it.body?.string() ?: "success"))
+              it.code == 401 -> callback(Result.failure(Exception("Unauthorized (401) - Check API Key")))
+              it.code == 500 -> callback(Result.failure(Exception("Server Error (500) - Try again later")))
+              else -> callback(Result.failure(Exception("HTTP Error: ${it.code} - ${it.message}")))
+            }
+          }
+        }
+      })
+    } catch (e: Exception) {
+      callback(Result.failure(e))
+    }
+  }
+
+  fun makePostRequest(urlString: String, postData: Any, callback: (Result<String>) -> Unit) {
+    makeHttpRequest(
+      urlString = urlString,
+      method = "POST",
+      headers = mapOf("Content-Type" to "application/json"),
+      body = postData.toString().takeIf { it != "null" },
+      callback = callback
+    )
+  }
+}

package/android/src/main/java/io/hyperswitch/react/Utils.kt

@@ -0,0 +1,23 @@
+package io.hyperswitch.react
+
+import kotlin.text.isNotEmpty
+import kotlin.text.startsWith
+
+enum class SDKEnvironment { SANDBOX, PROD }
+
+class Utils {
+  companion object {
+    fun checkEnvironment(publishableKey: String): SDKEnvironment {
+      return if (publishableKey.isNotEmpty() && publishableKey.startsWith("pk_prd_")) {
+        SDKEnvironment.PROD
+      } else {
+        SDKEnvironment.SANDBOX
+      }
+    }
+
+    fun getLoggingUrl(publishableKey: String): String {
+      return if (checkEnvironment(publishableKey) == SDKEnvironment.PROD) "https://api.hyperswitch.io/logs/sdk"
+      else "https://sandbox.hyperswitch.io/logs/sdk"
+    }
+  }
+}

package/android/src/main/res/values/attrs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <declare-styleable name="BasePaymentWidget">
+        <attr name="paymentMethod" format="string" />
+    </declare-styleable>
+</resources>

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,5 @@
+<resources>
+    <string name="app_name">HyperSwitch</string>
+    <string name="hyperOTAEndPoint">hyperOTA_END_POINT_</string>
+    <string name="hyperOTASandBoxEndPoint">hyperOTA_END_POINT_</string>
+</resources>

package/android/src/main/res/values/theme.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <style name="HyperTransparentTheme" parent="Theme.AppCompat.DayNight.NoActionBar">
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowContentOverlay">@null</item>
+        <item name="android:windowNoTitle">true</item>
+        <item name="android:backgroundDimEnabled">true</item>
+        <item name="android:windowAnimationStyle">@null</item>
+        <item name="android:windowDisablePreview">true</item>
+        <item name="android:windowTranslucentStatus">true</item>
+        <item name="android:windowTranslucentNavigation">true</item>
+        <item name="android:statusBarColor">@android:color/transparent</item>
+    </style>
+</resources>

package/ios/Modules/HyperswitchModule.swift

@@ -0,0 +1,61 @@
+//
+//  HyperswitchModule.swift
+//  Hyperswitch
+//
+//  Created by Harshit Srivastava on 12/09/25.
+//
+
+import Foundation
+import React
+
+@objc(HyperswitchModule)
+public class HyperswitchModule: NSObject {
+
+  @objc public static let shared: HyperswitchModule = HyperswitchModule()
+  var paymentSession: PaymentSession?
+
+  @objc(initialiseWithPublishableKey:customBackendUrl:customLogUrl:customParams:resolve:reject:)
+  public func initialise(publishableKey: String,
+                         customBackendUrl: String?,
+                         customLogUrl: String?,
+                         customParams: [String:Any],
+                         resolve: @escaping RCTPromiseResolveBlock,
+                         reject: @escaping RCTPromiseRejectBlock) -> Void {
+
+    self.paymentSession = PaymentSession(publishableKey: publishableKey,
+                                         customBackendUrl: customBackendUrl,
+                                         customParams: customParams,
+                                         customLogUrl: customLogUrl)
+    resolve(NSNull())
+  }
+  @objc(initPaymentSessionWithpaymentIntentClientSecret:resolve:reject:)
+  public func initPaymentSession(paymentIntentClientSecret: String,
+                                 resolve: @escaping RCTPromiseResolveBlock,
+                                 reject: @escaping RCTPromiseRejectBlock) -> Void {
+
+    self.paymentSession?.initPaymentSession(paymentIntentClientSecret: paymentIntentClientSecret)
+    resolve(NSNull())
+  }
+
+  @objc(presentPaymentSheetWithConfiguration:resolver:rejecter:)
+  public func presentPaymentSheet(configuration: [String:Any],
+                                  resolve: @escaping RCTPromiseResolveBlock,
+                                  reject: @escaping RCTPromiseRejectBlock) -> Void{
+    DispatchQueue.main.async {
+      guard let vc = RCTPresentedViewController() else {
+        reject("error", "Could not find presented view controller", NSError())
+        return
+      }
+      self.paymentSession?.presentPaymentSheetWithParams(viewController: vc, params: configuration, completion: { result in
+        switch result {
+        case .completed(let data):
+          resolve(["status": "completed", "message": data])
+        case .failed(let error as NSError):
+          resolve(["status": "failed", "code": error.domain, "message": "\(error.userInfo["message"] ?? "Failed")"])
+        case .canceled(let data):
+          resolve(["status": "cancelled", "message": data])
+        }
+      })
+    }
+  }
+}

package/ios/Modules/HyperswitchNativeModule.swift

@@ -0,0 +1,113 @@
+//
+//  HyperswitchNativeModule.swift
+//  Hyperswitch
+//
+//  Created by Harshit Srivastava on 12/09/25.
+//
+
+import Foundation
+import React
+
+@objc(HyperswitchNativeModule)
+public class HyperswitchNativeModule: NSObject {
+
+    @objc public static let shared: HyperswitchNativeModule = HyperswitchNativeModule()
+    private let applePayPaymentHandler = ApplePayHandler()
+    private var presentCallback: RCTResponseSenderBlock? = nil
+
+
+    @objc
+    public func sendMessageToNative(_ rnMessage: String) {}
+
+    @objc(launchApplePayWithRnMessage:rnCallback:)
+    public func launchApplePay (_ rnMessage: String, _ rnCallback: @escaping RCTResponseSenderBlock) {
+        applePayPaymentHandler.startPayment(rnMessage: rnMessage, rnCallback: rnCallback, presentCallback: self.presentCallback)
+    }
+
+    @objc(startApplePayWithRnMessage:rnCallback:)
+    public func startApplePay (_ rnMessage: String, _ rnCallback: @escaping RCTResponseSenderBlock) {
+        rnCallback([])
+    }
+
+    @objc(presentApplePayWithRnMessage:rnCallback:)
+    public func presentApplePay (_ rnMessage: String, _ rnCallback: @escaping RCTResponseSenderBlock) {
+        self.presentCallback = rnCallback
+    }
+
+    @objc(exitPaymentsheetWithRootTag:result:reset:)
+    public func exitPaymentsheet(_ reactTag: Double, _ rnMessage: String, _ reset: Bool) {
+        exitSheet(rnMessage)
+    }
+
+    //  @objc
+    //  private func exitWidgetPaymentsheet(_ reactTag: NSNumber, _ rnMessage: String, _ reset: Bool) {
+    //    exitSheet(rnMessage)
+    //  }
+    //
+    //  @objc
+    //  private func exitPaymentMethodManagement(_ reactTag: NSNumber, _ rnMessage: String, _ reset: Bool) {
+    //    exitSheet(rnMessage)
+    //  }
+
+    //  @objc
+    //  private func exitCardForm(_ rnMessage: String) {
+    //    var response: String?
+    //    var error: NSError?
+    //
+    //    if let data = rnMessage.data(using: .utf8) {
+    //      do {
+    //        if let jsonDictionary = try JSONSerialization.jsonObject(with: data, options: []) as? [String: String] {
+    //          let status = jsonDictionary["status"]
+    //
+    //          if (status == "failed" || status == "requires_payment_method") {
+    //            error = NSError(domain: (jsonDictionary["code"] ?? "") != "" ? jsonDictionary["code"]! : "UNKNOWN_ERROR", code: 0, userInfo: ["message" : jsonDictionary["message"] ?? "An error has occurred."])
+    //          } else {
+    //            response = status
+    //          }
+    //          RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: response, error: error)
+    //        } else {
+    //          RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+    //        }
+    //      } catch {
+    //        RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+    //      }
+    //    } else {
+    //      RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+    //    }
+    //  }
+
+    @objc
+    private func exitSheet(_ rnMessage: String) {
+        var response: String?
+        var error: NSError?
+
+        if let data = rnMessage.data(using: .utf8) {
+            do {
+                if let jsonDictionary = try JSONSerialization.jsonObject(with: data, options: []) as? [String: String] {
+                    let status = jsonDictionary["status"]
+
+                    if (status == "failed" || status == "requires_payment_method") {
+                        error = NSError(domain: (jsonDictionary["code"] ?? "") != "" ? jsonDictionary["code"]! : "UNKNOWN_ERROR", code: 0, userInfo: ["message" : jsonDictionary["message"] ?? "An error has occurred."])
+                    } else {
+                        response = status
+                    }
+                    RNFabricManager.sharedInstance.responseHandler?.didReceiveResponse(response: response, error: error)
+                } else {
+                    RNFabricManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+                }
+            } catch {
+                RNFabricManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+            }
+        } else {
+            RNFabricManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+        }
+        DispatchQueue.main.async {
+            if let view = RNFabricManager.sharedInstance.rootView {
+                let reactNativeVC: UIViewController? = view.reactViewController()
+                reactNativeVC?.dismiss(animated: false, completion: nil)
+            }
+        }
+    }
+}
+
+

package/ios/Modules/HyperswitchSdkNative.h

@@ -0,0 +1,5 @@
+#import <HyperswitchSdkReactNativeSpec/HyperswitchSdkReactNativeSpec.h>
+
+@interface HyperswitchSdkNative : NSObject <NativeHyperswitchSdkNativeSpec>
+
+@end

package/ios/Modules/HyperswitchSdkNative.mm

@@ -0,0 +1,98 @@
+#import "HyperswitchSdkNative.h"
+#if __has_include("HyperswitchSdkReactNative-Swift.h")
+#import "HyperswitchSdkReactNative-Swift.h"
+#else
+// When using use_frameworks! :linkage => :static in Podfile
+#import <HyperswitchSdkReactNative/HyperswitchSdkReactNative-Swift.h>
+#endif
+
+@implementation HyperswitchSdkNative
+RCT_EXPORT_MODULE(HyperModules)
+
+
+- (void)sendMessageToNative:(NSString *)message {
+  //    RCTLogInfo(@"sendMessageToNative called with: %@", message);
+  // Forward to other modules if needed
+}
+
+RCT_EXPORT_METHOD(launchApplePay:(NSString *)requestObj
+              callback:(RCTResponseSenderBlock)callback) {
+  [HyperswitchNativeModule.shared launchApplePayWithRnMessage:requestObj rnCallback:callback];
+}
+
+RCT_EXPORT_METHOD(startApplePay:(NSString *)requestObj
+             callback:(RCTResponseSenderBlock)callback) {
+  //    RCTLogInfo(@"startApplePay called with: %@", requestObj);
+  [HyperswitchNativeModule.shared startApplePayWithRnMessage:requestObj rnCallback:callback];
+
+}
+
+RCT_EXPORT_METHOD(presentApplePay:(NSString *)requestObj
+               callback:(RCTResponseSenderBlock)callback) {
+  [HyperswitchNativeModule.shared presentApplePayWithRnMessage:requestObj rnCallback:callback];
+}
+
+- (void)launchGPay:(NSString *)requestObj
+          callback:(RCTResponseSenderBlock)callback {
+  //    RCTLogInfo(@"launchGPay called");
+  // Google Pay is not available on iOS, but we can provide a callback
+  callback(@[@"Google Pay not available on iOS"]);
+}
+
+- (void)exitPaymentsheet:(double)rootTag
+                  result:(NSString *)result
+                   reset:(BOOL)reset {
+  [HyperswitchNativeModule.shared exitPaymentsheetWithRootTag:rootTag result:result reset:reset];
+}
+
+- (void)exitPaymentMethodManagement:(double)rootTag
+                             result:(NSString *)result
+                              reset:(BOOL)reset {
+  //    RCTLogInfo(@"exitPaymentMethodManagement called with rootTag: %f, result: %@, reset: %@", 
+  //               rootTag, result, reset ? @"YES" : @"NO");
+  // Implementation for exiting payment method management
+}
+
+- (void)exitWidget:(NSString *)result
+        widgetType:(NSString *)widgetType {
+  //    RCTLogInfo(@"exitWidget called with result: %@, widgetType: %@", result, widgetType);
+  // Implementation for exiting widget
+}
+
+- (void)exitCardForm:(NSString *)result {
+  //    RCTLogInfo(@"exitCardForm called with result: %@", result);
+  // Implementation for exiting card form
+}
+
+- (void)exitWidgetPaymentsheet:(double)rootTag
+                        result:(NSString *)result
+                         reset:(BOOL)reset {
+  //    RCTLogInfo(@"exitWidgetPaymentsheet called with rootTag: %f, result: %@, reset: %@", 
+  //               rootTag, result, reset ? @"YES" : @"NO");
+  // Implementation for exiting widget payment sheet
+}
+
+- (void)launchWidgetPaymentSheet:(NSString *)requestObj
+                        callback:(RCTResponseSenderBlock)callback {
+  //    RCTLogInfo(@"launchWidgetPaymentSheet called");
+  // Implementation for launching widget payment sheet
+  callback(@[@"Widget payment sheet implementation needed"]);
+}
+
+- (void)updateWidgetHeight:(double)height {
+  //    RCTLogInfo(@"updateWidgetHeight called with height: %f", height);
+  // Implementation for updating widget height
+}
+
+- (void)onAddPaymentMethod:(NSString *)data {
+  //    RCTLogInfo(@"onAddPaymentMethod called with data: %@", data);
+  // Implementation for adding payment method
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+(const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeHyperswitchSdkNativeSpecJSI>(params);
+}
+
+@end

package/ios/Modules/HyperswitchSdkReactNative.h

@@ -0,0 +1,5 @@
+#import <HyperswitchSdkReactNativeSpec/HyperswitchSdkReactNativeSpec.h>
+
+@interface HyperswitchSdkReactNative : NSObject <NativeHyperswitchSdkReactNativeSpec>
+
+@end