@amplytools/react-native-amply-sdk 0.1.0

package/expo-module.config.json

@@ -0,0 +1,11 @@
+{
+  "name": "amply-react-native",
+  "description": "React Native bridge for Amply Kotlin Multiplatform SDK",
+  "platforms": ["android", "ios"],
+  "android": {
+    "package": "com.amply.reactnative"
+  },
+  "ios": {
+    "podspecName": "AmplyReactNative"
+  }
+}

package/ios/AmplyReactNative.podspec

@@ -0,0 +1,32 @@
+Pod::Spec.new do |s|
+  s.name         = 'AmplyReactNative'
+  s.version      = '0.1.0-alpha.0'
+  s.summary      = 'React Native bridge for Amply SDK'
+  s.homepage     = 'https://github.com/amply/amply-react-native'
+  s.license      = { :type => 'MIT' }
+  s.authors      = { 'Amply' => 'opensource@amply.tools' }
+  s.source       = { :git => 'https://github.com/amply/amply-react-native.git', :tag => s.version.to_s }
+
+  s.platforms    = { :ios => '15.1' }
+  s.source_files = 'Sources/**/*.{swift,h,m,mm}'
+
+  # React Native dependencies for TurboModules
+  s.dependency 'React-Core'
+  s.dependency 'ReactCommon/turbomodule/core'
+  s.dependency 'React-RCTFabric'
+
+  # Amply KMP SDK from CocoaPods
+  s.dependency 'AmplySDK', '~> 0.1.7'
+
+  s.libraries = 'c++'
+  s.pod_target_xcconfig = {
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
+    'CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES' => 'YES',
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  # Enable modules for importing the AmplySDK framework
+  s.user_target_xcconfig = {
+    'CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES' => 'YES',
+  }
+end

package/ios/README.md

@@ -0,0 +1,11 @@
+# iOS Placeholder
+
+The Amply React Native Swift bridge will land once the Amply KMP XCFramework is published.
+
+Planned steps:
+
+1. Publish `AmplySDK.xcframework` + Swift Package.
+2. Replace placeholder Swift stubs with the generated TurboModule implementation.
+3. Wire CocoaPods + SPM manifests to consume the binary target.
+
+Until then, the module intentionally rejects calls on iOS builds.

package/ios/Sources/AmplyReactNative/AmplyModule.mm

@@ -0,0 +1,332 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTConvert.h>
+#import <React/RCTLog.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import "AmplyReactNative/AmplyReactNative.h"
+
+// Import the KMP SDK
+#import <AmplySDK/AmplySDK.h>
+
+using namespace facebook::react;
+
+@interface Amply : NativeAmplyModuleSpecBase <NativeAmplyModuleSpec, ASDKDeepLinkListener>
+@property (nonatomic, strong) ASDKAmply *amplyInstance;
+@property (nonatomic, assign) BOOL deepLinkListenerRegistered;
+@end
+
+@implementation Amply
+
+RCT_EXPORT_MODULE()
+
+- (void)initialize:(JS::NativeAmplyModule::AmplyInitializationConfig &)config
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  @try {
+    NSString *appId = config.appId();
+    NSString *apiKeyPublic = config.apiKeyPublic();
+    NSString *apiKeySecret = config.apiKeySecret();
+    NSString *defaultConfig = config.defaultConfig();
+
+    if (!appId || appId.length == 0) {
+      if (reject) {
+        reject(@"AMP_INVALID_CONFIG", @"'appId' is required", nil);
+      }
+      return;
+    }
+
+    if (!apiKeyPublic || apiKeyPublic.length == 0) {
+      if (reject) {
+        reject(@"AMP_INVALID_CONFIG", @"'apiKeyPublic' is required", nil);
+      }
+      return;
+    }
+
+    // Build the Amply config using the builder pattern
+    ASDKAmplyConfigBuilder *configBuilder = [[ASDKAmplyConfigBuilder alloc] init];
+
+    // Configure API settings using the api block
+    [configBuilder apiBlock:^(ASDKAmplyApiBuilder *apiBuilder) {
+      apiBuilder.appId = appId;
+      apiBuilder.apiKeyPublic = apiKeyPublic;
+      if (apiKeySecret && apiKeySecret.length > 0) {
+        apiBuilder.apiKeySecret = apiKeySecret;
+      }
+    }];
+
+    // Set default config if provided
+    if (defaultConfig && defaultConfig.length > 0) {
+      configBuilder.defaultConfig = defaultConfig;
+    }
+
+    ASDKAmplyConfig *amplyConfig = [configBuilder build];
+
+    // Create Amply instance
+    self.amplyInstance = [[ASDKAmply alloc] initWithConfig:amplyConfig];
+
+    RCTLogInfo(@"[AmplyReactNative] Initialized with appId=%@", appId);
+
+    if (resolve) {
+      resolve(nil);
+    }
+  } @catch (NSException *exception) {
+    RCTLogError(@"[AmplyReactNative] Failed to initialize: %@", exception.reason);
+    if (reject) {
+      reject(@"AMP_INIT_FAILED", exception.reason, nil);
+    }
+  }
+}
+
+- (NSNumber *)isInitialized
+{
+  return @(self.amplyInstance != nil);
+}
+
+- (void)track:(JS::NativeAmplyModule::TrackEventPayload &)payload
+      resolve:(RCTPromiseResolveBlock)resolve
+       reject:(RCTPromiseRejectBlock)reject
+{
+  if (!self.amplyInstance) {
+    if (reject) {
+      reject(@"AMP_NOT_INITIALIZED", @"Amply has not been initialized yet", nil);
+    }
+    return;
+  }
+
+  @try {
+    NSString *eventName = payload.name();
+
+    if (!eventName || eventName.length == 0) {
+      if (reject) {
+        reject(@"AMP_INVALID_EVENT", @"Event 'name' is required", nil);
+      }
+      return;
+    }
+
+    // Convert properties to NSDictionary
+    NSDictionary *properties = @{};
+    id<NSObject> propsObj = payload.properties();
+    if (propsObj && [propsObj isKindOfClass:[NSDictionary class]]) {
+      properties = (NSDictionary *)propsObj;
+    }
+
+    // Use the correct method signature: trackEvent:properties:
+    [self.amplyInstance trackEvent:eventName properties:properties];
+
+    RCTLogInfo(@"[AmplyReactNative] Tracked event: %@", eventName);
+
+    if (resolve) {
+      resolve(nil);
+    }
+  } @catch (NSException *exception) {
+    RCTLogError(@"[AmplyReactNative] Failed to track event: %@", exception.reason);
+    if (reject) {
+      reject(@"AMP_TRACK_FAILED", exception.reason, nil);
+    }
+  }
+}
+
+- (void)getRecentEvents:(double)limit
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject
+{
+  if (!self.amplyInstance) {
+    if (reject) {
+      reject(@"AMP_NOT_INITIALIZED", @"Amply has not been initialized yet", nil);
+    }
+    return;
+  }
+
+  // Use the async completion handler API
+  [self.amplyInstance getRecentEventsLimit:(int32_t)limit completionHandler:^(NSArray<id<ASDKEventInterface>> *events, NSError *error) {
+    if (error) {
+      RCTLogError(@"[AmplyReactNative] Failed to get recent events: %@", error.localizedDescription);
+      if (reject) {
+        reject(@"AMP_EVENTS_FAILED", error.localizedDescription, error);
+      }
+      return;
+    }
+
+    NSMutableArray *result = [NSMutableArray array];
+
+    for (id<ASDKEventInterface> event in events) {
+      NSMutableDictionary *eventDict = [NSMutableDictionary dictionary];
+      eventDict[@"name"] = event.name;
+      eventDict[@"timestamp"] = @(event.timestamp);
+      eventDict[@"type"] = event.type.name;
+      eventDict[@"properties"] = event.properties ?: @{};
+      [result addObject:eventDict];
+    }
+
+    RCTLogInfo(@"[AmplyReactNative] Fetched %lu recent events", (unsigned long)result.count);
+
+    if (resolve) {
+      resolve(result);
+    }
+  }];
+}
+
+- (void)getDataSetSnapshot:(NSDictionary *)type
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject
+{
+  if (!self.amplyInstance) {
+    if (reject) {
+      reject(@"AMP_NOT_INITIALIZED", @"Amply has not been initialized yet", nil);
+    }
+    return;
+  }
+
+  NSString *kind = type[@"kind"];
+  RCTLogInfo(@"[AmplyReactNative] getDataSetSnapshot called with kind: %@", kind);
+
+  // Convert JS type to native ASDKDataSetType
+  ASDKDataSetType *dataSetType = nil;
+
+  if ([kind isEqualToString:@"@device"]) {
+    dataSetType = ASDKDataSetTypeDevice.shared;
+  } else if ([kind isEqualToString:@"@user"]) {
+    dataSetType = ASDKDataSetTypeUser.shared;
+  } else if ([kind isEqualToString:@"@session"]) {
+    dataSetType = ASDKDataSetTypeSession.shared;
+  } else {
+    if (reject) {
+      reject(@"AMP_INVALID_TYPE", [NSString stringWithFormat:@"Unknown dataset type: %@", kind], nil);
+    }
+    return;
+  }
+
+  [self.amplyInstance getDataSetSnapshotType:dataSetType completionHandler:^(NSDictionary<NSString *, id> *snapshot, NSError *error) {
+    if (error) {
+      RCTLogError(@"[AmplyReactNative] Failed to get data set snapshot: %@", error.localizedDescription);
+      if (reject) {
+        reject(@"AMP_DATASET_FAILED", error.localizedDescription, error);
+      }
+      return;
+    }
+
+    RCTLogInfo(@"[AmplyReactNative] Got dataset snapshot: %@", snapshot);
+
+    if (resolve) {
+      resolve(snapshot ?: @{});
+    }
+  }];
+}
+
+/**
+ * Registers a listener for deep links triggered by Amply SDK campaigns.
+ *
+ * This listener allows app developers to:
+ * 1. Know that a deep link originated from Amply SDK (vs. external sources like
+ *    push notifications, browser links, or other SDKs)
+ * 2. Access campaign metadata via the `info` dictionary (campaign ID, variant, etc.)
+ *    that is not available in the URL itself
+ * 3. Track/log Amply-specific deep link events for analytics
+ *
+ * Example use case:
+ *   // In JS:
+ *   Amply.addDeepLinkListener(event => {
+ *     // We know this deep link came from an Amply campaign, not from elsewhere
+ *     analytics.track('Amply campaign triggered', { url: event.url, info: event.info });
+ *   });
+ *
+ * The deep link flow:
+ *   Campaign triggers → KMP SDK → onDeepLink callback → JS event emitted
+ *                                      ↓ (then)
+ *                              UIApplication.openURL() → Linking API
+ *
+ * Note: The listener is an observer, not a controller. The SDK will still open
+ * the URL via system after emitting the event.
+ *
+ * This ensures feature parity with Android implementation.
+ */
+- (void)registerDeepLinkListener
+{
+  if (!self.amplyInstance) {
+    RCTLogWarn(@"[AmplyReactNative] Cannot register deep link listener - Amply not initialized");
+    return;
+  }
+
+  if (self.deepLinkListenerRegistered) {
+    RCTLogInfo(@"[AmplyReactNative] Deep link listener already registered");
+    return;
+  }
+
+  RCTLogInfo(@"[AmplyReactNative] Registering deep link listener");
+  [self.amplyInstance registerDeepLinkListenerListener:self];
+  self.deepLinkListenerRegistered = YES;
+}
+
+#pragma mark - ASDKDeepLinkListener
+
+/**
+ * Called by KMP SDK when a campaign triggers a deep link action.
+ *
+ * @param url  The deep link URL configured in the campaign
+ * @param info Campaign metadata (may include campaign ID, action data, etc.)
+ * @return YES if the deep link was fully handled (SDK won't open URL via system)
+ *         NO  to let SDK also open the URL via UIApplication.openURL()
+ *
+ * Current implementation:
+ * 1. Emits event to JS via Amply.addDeepLinkListener() for custom handling/logging
+ * 2. Opens URL using modern UIApplication.open(_:options:completionHandler:) API
+ * 3. Returns YES to prevent SDK from using deprecated UIApplication.openURL()
+ *
+ * Note: KMP SDK uses deprecated UIApplication.openURL() which returns NO on iOS 18+,
+ * so we handle URL opening ourselves using the modern API.
+ */
+- (BOOL)onDeepLinkUrl:(NSString *)url info:(NSDictionary<NSString *, id> *)info
+{
+  RCTLogInfo(@"[AmplyReactNative] Received deep link from Amply: url=%@", url);
+
+  NSDictionary *payload = @{
+    @"url": url ?: @"",
+    @"info": info ?: @{},
+    @"consumed": @NO
+  };
+
+  [self emitOnDeepLink:payload];
+
+  // For custom scheme URLs (e.g., amply://), let JS handle navigation via the event above.
+  // For external URLs (http/https), open via system.
+  NSURL *nsUrl = [NSURL URLWithString:url];
+  if (nsUrl) {
+    NSString *scheme = nsUrl.scheme.lowercaseString;
+    BOOL isExternalUrl = [scheme isEqualToString:@"http"] || [scheme isEqualToString:@"https"];
+
+    if (isExternalUrl) {
+      dispatch_async(dispatch_get_main_queue(), ^{
+        [[UIApplication sharedApplication] openURL:nsUrl
+                                           options:@{}
+                                 completionHandler:^(BOOL success) {
+          if (!success) {
+            RCTLogWarn(@"[AmplyReactNative] Failed to open URL: %@", url);
+          }
+        }];
+      });
+    }
+  }
+
+  return YES; // Tell SDK we handled it
+}
+
+- (void)addListener:(NSString *)eventName
+{
+  // Required by RN EventEmitter contracts.
+  RCTLogInfo(@"[AmplyReactNative] addListener called for event: %@", eventName);
+}
+
+- (void)removeListeners:(double)count
+{
+  // Required by RN EventEmitter contracts.
+  RCTLogInfo(@"[AmplyReactNative] removeListeners called with count: %f", count);
+}
+
+- (std::shared_ptr<TurboModule>)getTurboModule:(const ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<NativeAmplyModuleSpecJSI>(params);
+}
+
+@end

package/ios/Sources/AmplyReactNative/AmplyReactNative/AmplyReactNative-generated.mm

@@ -0,0 +1,111 @@
+/**
+ * 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: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#import "AmplyReactNative.h"
+
+
+@implementation NativeAmplyModuleSpecBase
+- (void)emitOnSystemEvent:(NSDictionary *)value
+{
+  _eventEmitterCallback("onSystemEvent", value);
+}
+- (void)emitOnDeepLink:(NSDictionary *)value
+{
+  _eventEmitterCallback("onDeepLink", value);
+}
+
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper
+{
+  _eventEmitterCallback = std::move(eventEmitterCallbackWrapper->_eventEmitterCallback);
+}
+@end
+
+@implementation RCTCxxConvert (NativeAmplyModule_AmplyInitializationConfig)
++ (RCTManagedPointer *)JS_NativeAmplyModule_AmplyInitializationConfig:(id)json
+{
+  return facebook::react::managedPointer<JS::NativeAmplyModule::AmplyInitializationConfig>(json);
+}
+@end
+@implementation RCTCxxConvert (NativeAmplyModule_TrackEventPayload)
++ (RCTManagedPointer *)JS_NativeAmplyModule_TrackEventPayload:(id)json
+{
+  return facebook::react::managedPointer<JS::NativeAmplyModule::TrackEventPayload>(json);
+}
+@end
+namespace facebook::react {
+  
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_initialize(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "initialize", @selector(initialize:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_isInitialized(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, BooleanKind, "isInitialized", @selector(isInitialized), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_track(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "track", @selector(track:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "getRecentEvents", @selector(getRecentEvents:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_getDataSetSnapshot(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "getDataSetSnapshot", @selector(getDataSetSnapshot:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_registerDeepLinkListener(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "registerDeepLinkListener", @selector(registerDeepLinkListener), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_addListener(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "addListener", @selector(addListener:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_removeListeners(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "removeListeners", @selector(removeListeners:), args, count);
+    }
+
+  NativeAmplyModuleSpecJSI::NativeAmplyModuleSpecJSI(const ObjCTurboModule::InitParams &params)
+    : ObjCTurboModule(params) {
+      
+        methodMap_["initialize"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_initialize};
+        setMethodArgConversionSelector(@"initialize", 0, @"JS_NativeAmplyModule_AmplyInitializationConfig:");
+        
+        methodMap_["isInitialized"] = MethodMetadata {0, __hostFunction_NativeAmplyModuleSpecJSI_isInitialized};
+        
+        
+        methodMap_["track"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_track};
+        setMethodArgConversionSelector(@"track", 0, @"JS_NativeAmplyModule_TrackEventPayload:");
+        
+        methodMap_["getRecentEvents"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents};
+        
+        
+        methodMap_["getDataSetSnapshot"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getDataSetSnapshot};
+        
+        
+        methodMap_["registerDeepLinkListener"] = MethodMetadata {0, __hostFunction_NativeAmplyModuleSpecJSI_registerDeepLinkListener};
+        
+        
+        methodMap_["addListener"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_addListener};
+        
+        
+        methodMap_["removeListeners"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_removeListeners};
+        
+        eventEmitterMap_["onSystemEvent"] = std::make_shared<AsyncEventEmitter<id>>();
+        eventEmitterMap_["onDeepLink"] = std::make_shared<AsyncEventEmitter<id>>();
+        setEventEmitterCallback([&](const std::string &name, id value) {
+          static_cast<AsyncEventEmitter<id> &>(*eventEmitterMap_[name]).emit(value);
+        });
+  }
+} // namespace facebook::react

package/ios/Sources/AmplyReactNative/AmplyReactNative/AmplyReactNative.h

@@ -0,0 +1,152 @@
+/**
+ * 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: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#ifndef __cplusplus
+#error This file must be compiled as Obj-C++. If you are importing it, you must change your file extension to .mm.
+#endif
+
+// Avoid multiple includes of AmplyReactNative symbols
+#ifndef AmplyReactNative_H
+#define AmplyReactNative_H
+
+#import <Foundation/Foundation.h>
+#import <RCTRequired/RCTRequired.h>
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <RCTTypeSafety/RCTTypedModuleConstants.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTCxxConvert.h>
+#import <React/RCTManagedPointer.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <optional>
+#import <vector>
+
+
+NS_ASSUME_NONNULL_BEGIN
+namespace JS {
+  namespace NativeAmplyModule {
+    struct AmplyInitializationConfig {
+      NSString *appId() const;
+      NSString *apiKeyPublic() const;
+      NSString *apiKeySecret() const;
+      NSString *endpoint() const;
+      id<NSObject> _Nullable datasetPrefetch() const;
+      NSString *defaultConfig() const;
+
+      AmplyInitializationConfig(NSDictionary *const v) : _v(v) {}
+    private:
+      NSDictionary *_v;
+    };
+  }
+}
+
+@interface RCTCxxConvert (NativeAmplyModule_AmplyInitializationConfig)
++ (RCTManagedPointer *)JS_NativeAmplyModule_AmplyInitializationConfig:(id)json;
+@end
+namespace JS {
+  namespace NativeAmplyModule {
+    struct TrackEventPayload {
+      NSString *name() const;
+      id<NSObject> _Nullable properties() const;
+
+      TrackEventPayload(NSDictionary *const v) : _v(v) {}
+    private:
+      NSDictionary *_v;
+    };
+  }
+}
+
+@interface RCTCxxConvert (NativeAmplyModule_TrackEventPayload)
++ (RCTManagedPointer *)JS_NativeAmplyModule_TrackEventPayload:(id)json;
+@end
+@protocol NativeAmplyModuleSpec <RCTBridgeModule, RCTTurboModule>
+
+- (void)initialize:(JS::NativeAmplyModule::AmplyInitializationConfig &)config
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject;
+- (NSNumber *)isInitialized;
+- (void)track:(JS::NativeAmplyModule::TrackEventPayload &)payload
+      resolve:(RCTPromiseResolveBlock)resolve
+       reject:(RCTPromiseRejectBlock)reject;
+- (void)getRecentEvents:(double)limit
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject;
+- (void)getDataSetSnapshot:(NSDictionary *)type
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject;
+- (void)registerDeepLinkListener;
+- (void)addListener:(NSString *)eventName;
+- (void)removeListeners:(double)count;
+
+@end
+
+@interface NativeAmplyModuleSpecBase : NSObject {
+@protected
+facebook::react::EventEmitterCallback _eventEmitterCallback;
+}
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper;
+
+- (void)emitOnSystemEvent:(NSDictionary *)value;
+- (void)emitOnDeepLink:(NSDictionary *)value;
+@end
+
+namespace facebook::react {
+  /**
+   * ObjC++ class for module 'NativeAmplyModule'
+   */
+  class JSI_EXPORT NativeAmplyModuleSpecJSI : public ObjCTurboModule {
+  public:
+    NativeAmplyModuleSpecJSI(const ObjCTurboModule::InitParams &params);
+  };
+} // namespace facebook::react
+inline NSString *JS::NativeAmplyModule::AmplyInitializationConfig::appId() const
+{
+  id const p = _v[@"appId"];
+  return RCTBridgingToString(p);
+}
+inline NSString *JS::NativeAmplyModule::AmplyInitializationConfig::apiKeyPublic() const
+{
+  id const p = _v[@"apiKeyPublic"];
+  return RCTBridgingToString(p);
+}
+inline NSString *JS::NativeAmplyModule::AmplyInitializationConfig::apiKeySecret() const
+{
+  id const p = _v[@"apiKeySecret"];
+  return RCTBridgingToOptionalString(p);
+}
+inline NSString *JS::NativeAmplyModule::AmplyInitializationConfig::endpoint() const
+{
+  id const p = _v[@"endpoint"];
+  return RCTBridgingToOptionalString(p);
+}
+inline id<NSObject> _Nullable JS::NativeAmplyModule::AmplyInitializationConfig::datasetPrefetch() const
+{
+  id const p = _v[@"datasetPrefetch"];
+  return p;
+}
+inline NSString *JS::NativeAmplyModule::AmplyInitializationConfig::defaultConfig() const
+{
+  id const p = _v[@"defaultConfig"];
+  return RCTBridgingToOptionalString(p);
+}
+inline NSString *JS::NativeAmplyModule::TrackEventPayload::name() const
+{
+  id const p = _v[@"name"];
+  return RCTBridgingToString(p);
+}
+inline id<NSObject> _Nullable JS::NativeAmplyModule::TrackEventPayload::properties() const
+{
+  id const p = _v[@"properties"];
+  return p;
+}
+NS_ASSUME_NONNULL_END
+#endif // AmplyReactNative_H