@mapvina-com/mapvina-react-native 1.0.0

package/ios/modules/static-map/MLRNStaticMapModule.mm

@@ -0,0 +1,84 @@
+#import "MLRNStaticMapModule.h"
+#import <MapVina/MapVina.h>
+#import <React/RCTConvert.h>
+#import "MLRNImageUtils.h"
+#import "MLRNUtils.h"
+
+@implementation MLRNStaticMapModule
+
++ (NSString *)moduleName {
+  return @"MLRNStaticMapModule";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeStaticMapModuleSpecJSI>(params);
+}
+
+- (void)createImage:(JS::NativeStaticMapModule::NativeStaticMapCreateOptions &)options
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject {
+  MLNMapSnapshotOptions *mapSnapshotOptions = [self _getOptions:options];
+  NSString *output = options.output();
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    MLNMapSnapshotter *snapshotter = [[MLNMapSnapshotter alloc] initWithOptions:mapSnapshotOptions];
+    __block MLNMapSnapshotter *snapshotterRef = snapshotter;
+
+    [snapshotter
+        startWithCompletionHandler:^(MLNMapSnapshot *_Nullable snapshot, NSError *_Nullable error) {
+          if (error) {
+            snapshotterRef = nil;
+            reject(@"createImage", @"Could not create static map image", error);
+            return;
+          }
+
+          NSString *result = nil;
+          if ([output isEqual:@"file"]) {
+            result = [MLRNImageUtils createTempFile:snapshot.image];
+          } else if ([output isEqual:@"base64"]) {
+            result = [MLRNImageUtils createBase64:snapshot.image];
+          }
+
+          snapshotterRef = nil;
+          resolve(result);
+        }];
+  });
+}
+
+- (MLNMapSnapshotOptions *)_getOptions:
+    (JS::NativeStaticMapModule::NativeStaticMapCreateOptions &)options {
+  MLNMapCamera *camera = [[MLNMapCamera alloc] init];
+
+  camera.pitch = options.pitch().value_or(0.0);
+  camera.heading = options.bearing().value_or(0.0);
+
+  if (options.center().has_value() && options.center().value().size() == 2) {
+    camera.centerCoordinate = [MLRNUtils fromLongitude:@(options.center().value()[0])
+                                              latitude:@(options.center().value()[1])];
+  }
+
+  CGSize size = CGSizeMake(options.width(), options.height());
+
+  MLNMapSnapshotOptions *mapSnapshotOptions = [[MLNMapSnapshotOptions alloc]
+      initWithStyleURL:[MLRNUtils styleURLFromMapStyle:options.mapStyle()]
+                camera:camera
+                  size:size];
+
+  if (options.bounds().has_value()) {
+    auto boundsArray = options.bounds().value();
+    mapSnapshotOptions.coordinateBounds = [MLRNUtils fromReactBounds:@[
+      @(boundsArray[0]), @(boundsArray[1]), @(boundsArray[2]), @(boundsArray[3])
+    ]];
+  }
+
+  if (options.zoom().has_value()) {
+    mapSnapshotOptions.zoomLevel = options.zoom().value();
+  }
+
+  mapSnapshotOptions.showsLogo = options.logo().value_or(false);
+
+  return mapSnapshotOptions;
+}
+
+@end

package/ios/modules/transform-request/MLRNTransformRequest.h

@@ -0,0 +1,38 @@
+#import <Foundation/Foundation.h>
+#import <MapVina/MLNNetworkConfiguration.h>
+
+@interface MLRNTransformRequest : NSObject <MLNNetworkConfigurationDelegate>
+
++ (MLRNTransformRequest *_Nonnull)sharedInstance;
+
+@property (nonatomic, copy, nullable) void (^logCallback)
+    (NSString *_Nonnull level, NSString *_Nonnull tag, NSString *_Nonnull message);
+
+- (void)addUrlTransform:(nonnull NSString *)transformId
+                  match:(nullable NSString *)match
+                   find:(nonnull NSString *)find
+                replace:(nonnull NSString *)replace;
+
+- (void)removeUrlTransform:(nonnull NSString *)transformId;
+
+- (void)clearUrlTransforms;
+
+- (void)addUrlSearchParam:(nonnull NSString *)transformId
+                    match:(nullable NSString *)match
+                     name:(nonnull NSString *)name
+                    value:(nonnull NSString *)value;
+
+- (void)removeUrlSearchParam:(nonnull NSString *)transformId;
+
+- (void)clearUrlSearchParams;
+
+- (void)addHeader:(nonnull NSString *)transformId
+            match:(nullable NSString *)match
+             name:(nonnull NSString *)name
+            value:(nonnull NSString *)value;
+
+- (void)removeHeader:(nonnull NSString *)transformId;
+
+- (void)clearHeaders;
+
+@end

package/ios/modules/transform-request/MLRNTransformRequest.m

@@ -0,0 +1,413 @@
+#import "MLRNTransformRequest.h"
+#import <MapVina/MLNNetworkConfiguration.h>
+#import <MapVina/MapVina.h>
+
+static NSString *MLRNTRMatchDescription(NSRegularExpression *_Nullable match) {
+  return match != nil ? [NSString stringWithFormat:@" (match='%@')", match.pattern] : @"";
+}
+
+// MARK: TransformConfig
+
+@interface TransformConfig : NSObject
+@property (nonatomic, copy) NSString *id;
+@property (nonatomic, strong, nullable) NSRegularExpression *match;
+
+- (instancetype)initWithId:(nonnull NSString *)id match:(nullable NSString *)match;
+@end
+
+@implementation TransformConfig
+
+- (instancetype)initWithId:(nonnull NSString *)id match:(nullable NSString *)match {
+  if (self = [super init]) {
+    _id = id;
+
+    if (match != nil) {
+      NSError *error = nil;
+      _match = [NSRegularExpression regularExpressionWithPattern:match options:0 error:&error];
+      if (error != nil) {
+        @throw [NSException
+            exceptionWithName:NSInvalidArgumentException
+                       reason:[NSString stringWithFormat:@"[MLRNTransformRequest] Invalid match "
+                                                         @"regex pattern '%@': %@",
+                                                         match, error.localizedDescription]
+                     userInfo:nil];
+      }
+    }
+  }
+
+  return self;
+}
+
+@end
+
+// MARK: UrlTransformConfig
+
+@interface UrlTransformConfig : TransformConfig
+@property (nonatomic, strong) NSRegularExpression *find;
+@property (nonatomic, strong) NSString *replace;
+
+- (instancetype)initWithId:(nonnull NSString *)id
+                     match:(nullable NSString *)match
+                      find:(nonnull NSString *)find
+                   replace:(nonnull NSString *)replace;
+@end
+
+@implementation UrlTransformConfig
+
+- (instancetype)initWithId:(nonnull NSString *)id
+                     match:(nullable NSString *)match
+                      find:(nonnull NSString *)find
+                   replace:(nonnull NSString *)replace {
+  if (self = [super initWithId:id match:match]) {
+    NSError *error = nil;
+    _find = [NSRegularExpression regularExpressionWithPattern:find options:0 error:&error];
+    if (error != nil || _find == nil) {
+      @throw [NSException
+          exceptionWithName:NSInvalidArgumentException
+                     reason:[NSString stringWithFormat:@"[MLRNTransformRequest] addUrlTransform "
+                                                       @"'%@': invalid find regex '%@': %@",
+                                                       id, find, error.localizedDescription]
+                   userInfo:nil];
+    }
+    _replace = replace;
+  }
+
+  return self;
+}
+
+@end
+
+// MARK: UrlSearchParamConfig
+
+@interface UrlSearchParamConfig : TransformConfig
+@property (nonatomic, strong) NSString *name;
+@property (nonatomic, strong) NSString *value;
+
+- (instancetype)initWithId:(nonnull NSString *)transformId
+                     match:(nullable NSString *)match
+                      name:(nonnull NSString *)name
+                     value:(nonnull NSString *)value;
+@end
+
+@implementation UrlSearchParamConfig
+
+- (instancetype)initWithId:(nonnull NSString *)id
+                     match:(nullable NSString *)match
+                      name:(nonnull NSString *)name
+                     value:(nonnull NSString *)value {
+  if (self = [super initWithId:id match:match]) {
+    _name = name;
+    _value = value;
+  }
+
+  return self;
+}
+
+@end
+
+// MARK: HeaderConfig
+
+@interface HeaderConfig : TransformConfig
+@property (nonatomic, strong) NSString *name;
+@property (nonatomic, strong) NSString *value;
+
+- (instancetype)initWithId:(nonnull NSString *)transformId
+                     match:(nullable NSString *)match
+                      name:(nonnull NSString *)name
+                     value:(nonnull NSString *)value;
+@end
+
+@implementation HeaderConfig
+
+- (instancetype)initWithId:(nonnull NSString *)transformId
+                     match:(nullable NSString *)match
+                      name:(nonnull NSString *)name
+                     value:(nonnull NSString *)value {
+  if (self = [super initWithId:transformId match:match]) {
+    _name = name;
+    _value = value;
+  }
+
+  return self;
+}
+
+@end
+
+// MARK: MLRNTransformRequest
+
+@implementation MLRNTransformRequest {
+  NSMutableArray<UrlTransformConfig *> *urlTransforms;
+  NSMutableArray<UrlSearchParamConfig *> *urlSearchParams;
+  NSMutableArray<HeaderConfig *> *headers;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    urlTransforms = [[NSMutableArray alloc] init];
+    urlSearchParams = [[NSMutableArray alloc] init];
+    headers = [[NSMutableArray alloc] init];
+    [[MLNNetworkConfiguration sharedManager] setDelegate:self];
+  }
+
+  return self;
+}
+
++ (MLRNTransformRequest *)sharedInstance {
+  static MLRNTransformRequest *transformRequest;
+  static dispatch_once_t onceToken;
+
+  dispatch_once(&onceToken, ^{
+    transformRequest = [[self alloc] init];
+  });
+
+  return transformRequest;
+}
+
+// MARK: Logging
+
+- (void)debugLog:(NSString *)message {
+#ifdef DEBUG
+  NSLog(@"[TransformRequest] %@", message);
+#endif
+  if (self.logCallback) {
+    self.logCallback(@"debug", @"TransformRequest", message);
+  }
+}
+
+- (void)errorLog:(NSString *)message {
+  NSLog(@"[TransformRequest] ERROR: %@", message);
+  if (self.logCallback) {
+    self.logCallback(@"error", @"TransformRequest", message);
+  }
+}
+
+// MARK: URL Transforms
+
+- (void)addUrlTransform:(NSString *)transformId
+                  match:(nullable NSString *)match
+                   find:(NSString *)find
+                replace:(NSString *)replace {
+  UrlTransformConfig *config = [[UrlTransformConfig alloc] initWithId:transformId
+                                                                match:match
+                                                                 find:find
+                                                              replace:replace];
+
+  for (UrlTransformConfig *existing in urlTransforms) {
+    if ([existing.id isEqualToString:transformId]) {
+      NSUInteger idx = [urlTransforms indexOfObject:existing];
+      [urlTransforms replaceObjectAtIndex:idx withObject:config];
+      return;
+    }
+  }
+
+  [urlTransforms addObject:config];
+}
+
+- (void)removeUrlTransform:(NSString *)transformId {
+  NSUInteger idx = [urlTransforms
+      indexOfObjectPassingTest:^BOOL(UrlTransformConfig *c, NSUInteger i, BOOL *stop) {
+        return [c.id isEqualToString:transformId];
+      }];
+  if (idx != NSNotFound) {
+    [urlTransforms removeObjectAtIndex:idx];
+  }
+}
+
+- (void)clearUrlTransforms {
+  [urlTransforms removeAllObjects];
+}
+
+// MARK: URL Search Params
+
+- (void)addUrlSearchParam:(NSString *)transformId
+                    match:(nullable NSString *)match
+                     name:(NSString *)name
+                    value:(NSString *)value {
+  UrlSearchParamConfig *config = [[UrlSearchParamConfig alloc] initWithId:transformId
+                                                                    match:match
+                                                                     name:name
+                                                                    value:value];
+
+  // Update in-place when the id already exists — preserves order
+  for (UrlSearchParamConfig *existing in urlSearchParams) {
+    if ([existing.id isEqualToString:transformId]) {
+      NSUInteger idx = [urlSearchParams indexOfObject:existing];
+      [urlSearchParams replaceObjectAtIndex:idx withObject:config];
+      return;
+    }
+  }
+
+  [urlSearchParams addObject:config];
+}
+
+- (void)removeUrlSearchParam:(NSString *)transformId {
+  NSUInteger idx = [urlSearchParams
+      indexOfObjectPassingTest:^BOOL(UrlSearchParamConfig *c, NSUInteger i, BOOL *stop) {
+        return [c.id isEqualToString:transformId];
+      }];
+  if (idx != NSNotFound) {
+    [urlSearchParams removeObjectAtIndex:idx];
+  }
+}
+
+- (void)clearUrlSearchParams {
+  [urlSearchParams removeAllObjects];
+}
+
+// MARK: Headers
+
+- (void)addHeader:(NSString *)transformId
+            match:(nullable NSString *)match
+             name:(NSString *)name
+            value:(NSString *)value {
+  HeaderConfig *config = [[HeaderConfig alloc] initWithId:transformId
+                                                    match:match
+                                                     name:name
+                                                    value:value];
+
+  for (HeaderConfig *existing in headers) {
+    if ([existing.id isEqualToString:transformId]) {
+      NSUInteger idx = [headers indexOfObject:existing];
+      [headers replaceObjectAtIndex:idx withObject:config];
+      return;
+    }
+  }
+
+  [headers addObject:config];
+}
+
+- (void)removeHeader:(NSString *)transformId {
+  NSUInteger idx =
+      [headers indexOfObjectPassingTest:^BOOL(HeaderConfig *c, NSUInteger i, BOOL *stop) {
+        return [c.id isEqualToString:transformId];
+      }];
+  if (idx != NSNotFound) {
+    [headers removeObjectAtIndex:idx];
+  }
+}
+
+- (void)clearHeaders {
+  [headers removeAllObjects];
+}
+
+// MARK: MLNNetworkConfigurationDelegate
+
+- (NSMutableURLRequest *)willSendRequest:(NSMutableURLRequest *)request {
+  NSArray<UrlTransformConfig *> *currentTransforms = [urlTransforms copy];
+  NSArray<UrlSearchParamConfig *> *currentParams = [urlSearchParams copy];
+  NSArray<HeaderConfig *> *currentHeaders = [headers copy];
+
+  BOOL hasConfig =
+      currentTransforms.count > 0 || currentParams.count > 0 || currentHeaders.count > 0;
+
+  if (hasConfig) {
+    [self debugLog:[NSString stringWithFormat:@"Request: %@", request.URL.absoluteString]];
+  }
+
+  // 1. URL transforms
+  for (UrlTransformConfig *config in currentTransforms) {
+    NSString *currentUrl = request.URL.absoluteString;
+
+    if (config.match != nil) {
+      NSRange r = [config.match rangeOfFirstMatchInString:currentUrl
+                                                  options:0
+                                                    range:NSMakeRange(0, currentUrl.length)];
+      if (r.location == NSNotFound) {
+        [self debugLog:[NSString stringWithFormat:@"  URL Transform [%@]%@: SKIPPED (no match)",
+                                                  config.id, MLRNTRMatchDescription(config.match)]];
+        continue;
+      }
+    }
+
+    NSString *transformed =
+        [config.find stringByReplacingMatchesInString:currentUrl
+                                              options:0
+                                                range:NSMakeRange(0, currentUrl.length)
+                                         withTemplate:config.replace];
+    NSURL *newURL = [NSURL URLWithString:transformed];
+    if (newURL == nil) {
+      [self errorLog:[NSString stringWithFormat:@"URL Transform [%@]%@: produced invalid URL '%@',"
+                                                @" using pre-transform URL",
+                                                config.id, MLRNTRMatchDescription(config.match),
+                                                transformed]];
+    } else {
+      [self debugLog:[NSString stringWithFormat:@"  URL Transform [%@]%@: APPLIED '%@' → '%@'",
+                                                config.id, MLRNTRMatchDescription(config.match),
+                                                currentUrl, transformed]];
+      [request setURL:newURL];
+    }
+  }
+
+  // 2. URL search params
+  if (currentParams.count > 0) {
+    NSURLComponents *urlComponents = [NSURLComponents componentsWithURL:request.URL
+                                                resolvingAgainstBaseURL:NO];
+    NSMutableArray<NSURLQueryItem *> *queryItems =
+        [NSMutableArray arrayWithArray:urlComponents.queryItems ?: @[]];
+
+    for (UrlSearchParamConfig *config in currentParams) {
+      BOOL shouldApply = YES;
+
+      if (config.match != nil) {
+        NSRange range = [config.match
+            rangeOfFirstMatchInString:request.URL.absoluteString
+                              options:0
+                                range:NSMakeRange(0, request.URL.absoluteString.length)];
+        shouldApply = (range.location != NSNotFound);
+      }
+
+      if (shouldApply) {
+        [self debugLog:[NSString stringWithFormat:@"  URL Search Param [%@]%@: APPLIED '%@=%@'",
+                                                  config.id, MLRNTRMatchDescription(config.match),
+                                                  config.name, config.value]];
+
+        for (NSInteger i = queryItems.count - 1; i >= 0; i--) {
+          if ([queryItems[(NSUInteger)i].name isEqualToString:config.name]) {
+            [queryItems removeObjectAtIndex:(NSUInteger)i];
+          }
+        }
+
+        [queryItems addObject:[NSURLQueryItem queryItemWithName:config.name value:config.value]];
+      } else {
+        [self debugLog:[NSString stringWithFormat:@"  URL Search Param [%@]%@: SKIPPED (no match)",
+                                                  config.id, MLRNTRMatchDescription(config.match)]];
+      }
+    }
+
+    urlComponents.queryItems = queryItems;
+    if (urlComponents.URL != nil) {
+      [request setURL:urlComponents.URL];
+    }
+  }
+
+  // 3. Headers
+  for (HeaderConfig *config in currentHeaders) {
+    BOOL shouldApply = YES;
+
+    if (config.match != nil) {
+      NSRange range = [config.match
+          rangeOfFirstMatchInString:request.URL.absoluteString
+                            options:0
+                              range:NSMakeRange(0, request.URL.absoluteString.length)];
+      shouldApply = (range.location != NSNotFound);
+    }
+
+    if (shouldApply) {
+      [self debugLog:[NSString stringWithFormat:@"  Header [%@]%@: APPLIED '%@: %@'", config.id,
+                                                MLRNTRMatchDescription(config.match), config.name,
+                                                config.value]];
+      [request setValue:config.value forHTTPHeaderField:config.name];
+    } else {
+      [self debugLog:[NSString stringWithFormat:@"  Header [%@]%@: SKIPPED (no match)", config.id,
+                                                MLRNTRMatchDescription(config.match)]];
+    }
+  }
+
+  if (hasConfig) {
+    [self debugLog:[NSString stringWithFormat:@"Final URL: %@", request.URL.absoluteString]];
+  }
+
+  return request;
+}
+
+@end

package/ios/modules/transform-request/MLRNTransformRequestModule.h

@@ -0,0 +1,9 @@
+#import <MapVinaReactNativeSpec/MapVinaReactNativeSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MLRNTransformRequestModule
+    : NativeTransformRequestModuleSpecBase <NativeTransformRequestModuleSpec>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/modules/transform-request/MLRNTransformRequestModule.mm

@@ -0,0 +1,72 @@
+#import "MLRNTransformRequestModule.h"
+#import "MLRNLogging.h"
+#import "MLRNTransformRequest.h"
+
+@implementation MLRNTransformRequestModule
+
++ (NSString *)moduleName {
+  return @"MLRNTransformRequestModule";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeTransformRequestModuleSpecJSI>(params);
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    MLRNLogging *logging = [[MLRNLogging alloc] init];
+    [MLRNTransformRequest sharedInstance].logCallback =
+        ^(NSString *level, NSString *tag, NSString *message) {
+          [logging forwardLog:level tag:tag message:message];
+        };
+  }
+  return self;
+}
+
+- (void)addUrlTransform:(NSString *)id
+                  match:(NSString *_Nullable)match
+                   find:(NSString *)find
+                replace:(NSString *)replace {
+  [MLRNTransformRequest.sharedInstance addUrlTransform:id match:match find:find replace:replace];
+}
+
+- (void)removeUrlTransform:(NSString *)id {
+  [MLRNTransformRequest.sharedInstance removeUrlTransform:id];
+}
+
+- (void)clearUrlTransforms {
+  [MLRNTransformRequest.sharedInstance clearUrlTransforms];
+}
+
+- (void)addUrlSearchParam:(NSString *)id
+                    match:(NSString *_Nullable)match
+                     name:(NSString *)name
+                    value:(NSString *)value {
+  [MLRNTransformRequest.sharedInstance addUrlSearchParam:id match:match name:name value:value];
+}
+
+- (void)removeUrlSearchParam:(NSString *)id {
+  [MLRNTransformRequest.sharedInstance removeUrlSearchParam:id];
+}
+
+- (void)clearUrlSearchParams {
+  [MLRNTransformRequest.sharedInstance clearUrlSearchParams];
+}
+
+- (void)addHeader:(NSString *)id
+            match:(NSString *_Nullable)match
+             name:(NSString *)name
+            value:(NSString *)value {
+  [MLRNTransformRequest.sharedInstance addHeader:id match:match name:name value:value];
+}
+
+- (void)removeHeader:(NSString *)id {
+  [MLRNTransformRequest.sharedInstance removeHeader:id];
+}
+
+- (void)clearHeaders {
+  [MLRNTransformRequest.sharedInstance clearHeaders];
+}
+
+@end

package/ios/utils/FilterParser.h

@@ -0,0 +1,7 @@
+#import <Foundation/Foundation.h>
+
+@interface FilterParser : NSObject
+
++ (NSPredicate *)parse:(NSArray *)filter;
+
+@end

package/ios/utils/FilterParser.m

@@ -0,0 +1,13 @@
+#import "FilterParser.h"
+#import <MapVina/MapVina.h>
+
+@implementation FilterParser
+
++ (NSPredicate *)parse:(NSArray *)filterList {
+  if (filterList == nil || filterList.count < 1) {
+    return nil;
+  }
+  return [NSPredicate predicateWithMLNJSONObject:filterList];
+}
+
+@end

package/ios/utils/MLRNEvent.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+#import "MLRNEventProtocol.h"
+
+@interface MLRNEvent : NSObject <MLRNEventProtocol>
+
+@property (nonatomic, copy) NSString *type;
+@property (nonatomic, strong) NSDictionary *payload;
+@property (nonatomic, readonly) NSTimeInterval timestamp;
+
++ (MLRNEvent *)makeEvent:(NSString *)eventType;
++ (MLRNEvent *)makeEvent:(NSString *)eventType withPayload:(NSDictionary *)payload;
+
+@end

package/ios/utils/MLRNEvent.m

@@ -0,0 +1,36 @@
+#import "MLRNEvent.h"
+
+@implementation MLRNEvent
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _timestamp = [[NSDate date] timeIntervalSince1970];
+  }
+
+  return self;
+}
+
+- (NSDictionary *)payload {
+  if (_payload == nil) {
+    return @{};
+  }
+
+  return _payload;
+}
+
+- (NSDictionary *)toJSON {
+  return self.payload;
+}
+
++ (MLRNEvent *)makeEvent:(NSString *)type {
+  return [MLRNEvent makeEvent:type withPayload:@{}];
+}
+
++ (MLRNEvent *)makeEvent:(NSString *)type withPayload:(NSDictionary *)payload {
+  MLRNEvent *event = [[MLRNEvent alloc] init];
+  event.type = type;
+  event.payload = payload;
+  return event;
+}
+
+@end

package/ios/utils/MLRNEventProtocol.h

@@ -0,0 +1,8 @@
+@protocol MLRNEventProtocol <NSObject>
+
+@property (nonatomic, copy) NSString *type;
+@property (nonatomic, strong) NSDictionary *payload;
+
+- (NSDictionary *)toJSON;
+
+@end