react-native-move-sdk 0.1.0

package/ios/NativeModule/DolphinSdk.h

@@ -0,0 +1,58 @@
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface DolphinSdkInternal: RCTEventEmitter
++(void)initIfPossibleWithLaunchOptions:(NSDictionary *) launchOptions;
+-(void)sendAppEvent:(NSString *) eventInfo;
+@end
+
+
+@interface RCT_EXTERN_MODULE(DolphinSdk, DolphinSdkInternal)
+
+RCT_EXTERN_METHOD(initialize: (NSString *)contractId
+                  accessToken: (NSString *)accessToken
+                  refreshToken: (NSString *)refreshToken
+                  productId: (NSInteger *)productId
+                  timelineDetectionServices: (NSArray<NSString> *)timelineDetectionServices
+                  drivingServices: (NSArray<NSString> *)drivingServices
+                  walkingServices: (NSArray<NSString> *)walkingServices
+                  otherServices: (NSArray<NSString> *)otherServices
+                  resolve: (RCTPromiseResolveBlock)resolve
+                  reject: (RCTPromiseRejectBlock)reject
+                  )
+				  
+RCT_EXTERN_METHOD(getState: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+				  
+RCT_EXTERN_METHOD(getTripState: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+				  
+RCT_EXTERN_METHOD(startAutomaticDetection)
+
+RCT_EXTERN_METHOD(stopAutomaticDetection)
+
+RCT_EXTERN_METHOD(shutdown)
+
+RCT_EXTERN_METHOD(forceTripRecognition)
+
+RCT_EXTERN_METHOD(synchronizeUserData)
+
+RCT_EXTERN_METHOD(ignoreCurrentTrip)
+
+RCT_EXTERN_METHOD(finishCurrentTrip)
+
+RCT_EXTERN_METHOD(getAuthState: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(updateAuth: (NSString *)contractId
+                  accessToken: (NSString *)accessToken
+                  refreshToken: (NSString *)refreshToken
+                  productId: (NSInteger *)productId
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(resolveError)
+
+@end

package/ios/NativeModule/DolphinSdk.swift

@@ -0,0 +1,353 @@
+import Foundation
+import DolphinMoveSDK
+
+internal protocol DolphinSDKLauncherDelegate: AnyObject {
+	func send(event: DolphinSDKLauncher.Event, data: [String: Any])
+}
+
+@objc(DolphinSdk)
+class DolphinSdk: RCTEventEmitter {
+	private enum CError: String, Error {
+		case transformedServices = "Unknown driving service identifier in init parameters"
+		case transformedTimelineDetectionServices = "Unknown timeline service identifier in init parameters"
+		case transformedWalkingServices = "Unknown walking service identifier in init parameters"
+		case transformedOtherServices = "Unknown other service identifier in init parameters"
+	}
+
+	var ERROR_CODE = "DOLPHIN_SDK_ERROR"
+	
+	override init() {
+		super.init()
+		DolphinSDKLauncher.shared.delegate = self
+	}
+	
+	@objc
+	func initialize(_ contractId: String,
+									accessToken: String,
+									refreshToken: String,
+									productId: Int64,
+									timelineDetectionServices: Array<String>,
+									drivingServices: Array<String>,
+									walkingServices: Array<String>,
+									otherServices: Array<String>,
+									resolve: @escaping RCTPromiseResolveBlock,
+									reject: @escaping RCTPromiseRejectBlock) {
+		
+		do {
+			
+			let transformedServices: Array<MoveConfig.DrivingService> = try drivingServices.map {(s) -> MoveConfig.DrivingService in
+				if(s == "DistractionFreeDriving") {
+					return MoveConfig.DrivingService.dfd
+				}
+				else if(s == "DrivingBehaviour") {
+					return MoveConfig.DrivingService.behaviour
+				}
+				else {
+					throw CError.transformedServices
+				}
+			}
+			
+			let transformedTimelineDetectionServices: Array<MoveConfig.TimelineDetectionService> = try! timelineDetectionServices.map {(s) -> MoveConfig.TimelineDetectionService in
+				if(s == "DRIVING") {
+					return MoveConfig.TimelineDetectionService.driving
+				}
+				else if(s == "BICYCLE") {
+					return MoveConfig.TimelineDetectionService.bicycle
+				}
+				else if(s == "WALKING") {
+					return MoveConfig.TimelineDetectionService.walking
+				}
+				else if(s == "PUBLIC_TRANSPORT") {
+					return MoveConfig.TimelineDetectionService.publicTransport
+				}
+				else {
+					throw CError.transformedTimelineDetectionServices
+				}
+			}
+			
+			let transformedWalkingServices: Array<MoveConfig.WalkingService> = try walkingServices.map {(s) -> MoveConfig.WalkingService in
+				if(s == "Location") {
+					return MoveConfig.WalkingService.location
+				}
+				else {
+					throw CError.transformedWalkingServices
+				}
+			}
+			
+			let transformedOtherServices:  Array<MoveConfig.OtherService> = try otherServices.map {(s) -> MoveConfig.OtherService in
+				if(s == "PointsOfInterest") {
+					return MoveConfig.OtherService.poi
+				}
+				else {
+					throw CError.transformedOtherServices
+				}
+			}
+			
+			// TODO: Fix wrapper and add config option from RN for walking services (actually only 1 now)
+			let sdkConfig = MoveConfig(timelineDetectionService: transformedTimelineDetectionServices, drivingServices: transformedServices, walkingServices: transformedWalkingServices, otherServices: transformedOtherServices)
+			let auth = MoveAuth(userToken: accessToken, refreshToken: refreshToken, contractID: contractId, productID: productId)
+			
+			DispatchQueue.main.async {
+				DolphinSDKLauncher.shared.initialize(auth: auth, config: sdkConfig)
+			}
+			resolve("OK")
+		} catch {
+			reject("DOLPHIN_SDK_ERROR", "\(error)", nil)
+		}
+	}
+	
+	@objc
+	func getState(
+		_ resolve: RCTPromiseResolveBlock,
+		rejecter reject: RCTPromiseRejectBlock
+	) {
+		resolve("\(DolphinSDKLauncher.shared.sdk.getSDKState())")
+	}
+	
+	@objc
+	func getAuthState(
+		_ resolve: RCTPromiseResolveBlock,
+		rejecter reject: RCTPromiseRejectBlock
+	) {
+		resolve("\(DolphinSDKLauncher.shared.sdk.getAuthState())")
+	}
+	
+	@objc
+	func updateAuth(
+		_ contractId: String,
+		accessToken: String,
+		refreshToken: String,
+		productId: Int64,
+		resolver resolve: @escaping RCTPromiseResolveBlock,
+		rejecter reject: @escaping RCTPromiseRejectBlock
+	) {
+		let auth = MoveAuth(userToken: accessToken, refreshToken: refreshToken, contractID: contractId, productID: productId)
+
+		DolphinSDKLauncher.shared.sdk.update(auth: auth) { configurationError in
+			if let configurationError = configurationError {
+				reject("DolphinSdk-AuthState-ConfigurationError", "\(configurationError)", nil)
+			} else {
+				DolphinSDKLauncher.shared.sdkAuth = auth
+				resolve("OK")
+			}
+		}
+	}
+	
+	@objc
+	func getTripState(
+		_ resolve: RCTPromiseResolveBlock,
+		rejecter reject: RCTPromiseRejectBlock
+	) {
+		resolve("\(DolphinSDKLauncher.shared.sdk.getTripState())")
+	}
+	
+	@objc
+	func startAutomaticDetection() {
+		DolphinSDKLauncher.shared.startAutomaticDetection()
+	}
+	
+	@objc
+	func stopAutomaticDetection() {
+		DolphinSDKLauncher.shared.stopAutomaticDetection()
+	}
+	
+	@objc
+	func shutdown() {
+		DolphinSDKLauncher.shared.shutdown()
+	}
+	
+	@objc
+	func forceTripRecognition() {
+		DolphinSDKLauncher.shared.sdk.forceTripRecognition()
+	}
+	
+	@objc
+	func synchronizeUserData() {
+		DolphinSDKLauncher.shared.sdk.synchronizeUserData()
+	}
+	
+	@objc
+	func ignoreCurrentTrip() {
+		DolphinSDKLauncher.shared.sdk.ignoreCurrentTrip()
+	}
+	
+	@objc
+	func finishCurrentTrip() {
+		DolphinSDKLauncher.shared.sdk.finishCurrentTrip()
+	}
+
+	@objc
+	func resolveError() {
+		DolphinSDKLauncher.shared.sdk.resolveSDKStateError()
+	}
+	
+	@objc
+	func sendAppEvent(_ eventInfo: NSString) {
+	  self.sendEvent(withName: "DolphinSdk-AppEvent", body: ["eventInfo": "\(eventInfo)"])
+	}
+	
+	@objc public static func initIfPossibleWith(launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
+		DolphinSDKLauncher.shared.initIfPossibleWith(launchOptions: launchOptions)
+	}
+
+	override func supportedEvents() -> [String]! {
+	  return ["DolphinSdk-InitError", "DolphinSdk-State", "DolphinSdk-TripState", "DolphinSdk-AuthState", "DolphinSdk-AppEvent"]
+	}
+	
+	static override func moduleName() -> String! {
+		return "DolphinSdk"
+	}
+	
+	static override func requiresMainQueueSetup() -> Bool {
+		// To let React Native know if your module needs to be initialized on the main thread, before any JavaScript code executes.
+		// Otherwise you will see a warning that in the future your module may be initialized on a background thread unless you explicitly opt out
+		return true
+	}
+}
+
+extension DolphinSdk: DolphinSDKLauncherDelegate {
+	func send(event: DolphinSDKLauncher.Event, data: [String: Any]) {
+		sendEvent(withName: event.rawValue, body: data)
+	}
+}
+
+internal class DolphinSDKLauncher {
+	internal enum Event: String {
+		case sdkState = "DolphinSdk-State"
+		case tripState = "DolphinSdk-TripState"
+		case authState = "DolphinSdk-AuthState"
+		case initError = "DolphinSdk-InitError"
+	}
+
+	private enum DefaultsKey: String {
+		case auth = "MOVE.WRAPPER.AUTH"
+		case config = "MOVE.WRAPPER.CONFIG"
+	}
+	
+	weak var delegate: DolphinSDKLauncherDelegate?
+
+	static let shared = DolphinSDKLauncher()
+
+	let sdk = MoveSDK.shared
+	var launchOptions: [UIApplication.LaunchOptionsKey: Any]?
+
+	/// Persistence
+	internal var sdkAuth: DolphinMoveSDK.MoveAuth? {
+		didSet { DolphinSDKLauncher.encode(sdkAuth, forKey: .auth) }
+	}
+
+	private var sdkConfig: DolphinMoveSDK.MoveConfig? {
+		didSet { DolphinSDKLauncher.encode(sdkConfig, forKey: .config) }
+	}
+
+	private var isInRunningState: Bool {
+		didSet {
+			UserDefaults.standard.set(isInRunningState, forKey: "MOVE.WRAPPER.RUNNING")
+		}
+	}
+
+	init() {
+		sdkConfig = DolphinSDKLauncher.decode(.config)
+		sdkAuth = DolphinSDKLauncher.decode(.auth)
+
+		isInRunningState = UserDefaults.standard.bool(forKey: "MOVE.WRAPPER.RUNNING")
+
+		sdk.setSDKStateListener { state in
+			var data = ["state": "\(state)"]
+			switch (state) {
+			case let .error(stateError):
+				data["errorReason"] = "\(stateError)"
+			case .ready:
+				if self.isInRunningState {
+					self.sdk.startAutomaticDetection()
+				}
+			default:
+				break;
+			}
+			self.delegate?.send(event: .sdkState, data: data)
+		}
+		
+		sdk.setTripStateListener { state in
+			self.delegate?.send(event: .tripState, data: ["state": "\(state)"])
+		}
+		
+		sdk.setAuthStateUpdateListener { state in
+			var data = ["state": "\(state)"]
+			switch (state) {
+			case let .valid(auth):
+				self.sdkAuth = auth
+				data["accessToken"] = "\(auth.userToken)"
+				data["refreshToken"] = "\(auth.refreshToken)"
+			default:
+				break
+			}
+
+			self.delegate?.send(event: .authState, data: data)
+		}
+	}
+
+	internal func initIfPossibleWith(launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
+		self.launchOptions = launchOptions
+		/// warm start SDK
+		if isInRunningState, let auth = sdkAuth, let config = sdkConfig {
+			MoveSDK.shared.initialize(auth: auth, config: config, launchOptions: launchOptions) { initError in
+				if let error = initError {
+					self.delegate?.send(event: .initError, data: ["error": "\(error)"])
+				}
+			}
+		}
+	}
+	
+	internal func initialize(auth: DolphinMoveSDK.MoveAuth, config: DolphinMoveSDK.MoveConfig) {
+		MoveSDK.shared.initialize(auth: auth, config: config, launchOptions: self.launchOptions) { initError in
+			if let error = initError {
+				self.delegate?.send(event: .initError, data: ["error": "\(error)"])
+			} else {
+				/// store back config and auth for bg launch
+				self.sdkConfig = config
+				self.sdkAuth = auth
+			}
+		}
+	}
+	
+	func shutdown() {
+		isInRunningState = false
+		sdkAuth = nil
+		sdk.shutDown()
+	}
+	
+	func startAutomaticDetection() {
+		if !isInRunningState {
+			isInRunningState = true
+			sdk.startAutomaticDetection()
+		}
+	}
+
+	func stopAutomaticDetection() {
+		if isInRunningState {
+			isInRunningState = false
+			sdk.stopAutomaticDetection()
+		}
+	}
+
+	private static func decode<T>(_ key: DefaultsKey) -> T? where T: Decodable {
+		let decoder = PropertyListDecoder()
+
+		if let data = UserDefaults.standard.object(forKey: key.rawValue) as? Data {
+			return try? decoder.decode(T.self, from: data)
+		}
+
+		return nil
+	}
+
+	private static func encode<T>(_ encodable: T?, forKey key: DefaultsKey) where T: Encodable {
+		if let encodable = encodable {
+			let encoder = PropertyListEncoder()
+			if let data = try? encoder.encode(encodable) {
+				UserDefaults.standard.set(data, forKey: key.rawValue)
+			}
+		} else {
+			UserDefaults.standard.removeObject(forKey: key.rawValue)
+		}
+	}
+}

package/ios/NativeModule/DolphinSdkDemoReactNative-Bridging-Header.h

@@ -0,0 +1,8 @@
+//
+//  Use this file to import your target's public headers that you would like to expose to Swift.
+//
+
+#import "React/RCTBridgeModule.h"
+#import "React/RCTEventEmitter.h"
+
+#import <React/RCTBundleURLProvider.h>

package/lib/commonjs/index.js

@@ -0,0 +1,280 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _reactNative = require("react-native");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const {
+  DolphinSdk: NativeMoveSdk
+} = _reactNative.NativeModules;
+const eventEmitter = new _reactNative.NativeEventEmitter(NativeMoveSdk);
+
+class MoveSdk {
+  static sdkStateFromNative(nativeSdkState) {
+    var _stateString;
+
+    let stateString = nativeSdkState === null || nativeSdkState === void 0 ? void 0 : nativeSdkState.toLowerCase();
+
+    if ((_stateString = stateString) !== null && _stateString !== void 0 && _stateString.includes('(')) {
+      var _stateString2, _stateString3;
+
+      stateString = (_stateString2 = stateString) === null || _stateString2 === void 0 ? void 0 : _stateString2.substring(0, (_stateString3 = stateString) === null || _stateString3 === void 0 ? void 0 : _stateString3.indexOf('(')).toLowerCase();
+    }
+
+    switch (stateString) {
+      case 'uninitialized':
+        return MoveSdk.UNINITIALIZED;
+
+      case 'ready':
+        return MoveSdk.READY;
+
+      case 'running':
+        return MoveSdk.RUNNING;
+
+      case 'error':
+        return MoveSdk.ERROR;
+
+      default:
+        return null;
+    }
+  }
+
+  static tripStateFromNative(nativeTripState) {
+    const state = nativeTripState === null || nativeTripState === void 0 ? void 0 : nativeTripState.toLowerCase();
+
+    if ([MoveSdk.UNKNOWN, MoveSdk.DRIVING, MoveSdk.HALT, MoveSdk.IDLE, MoveSdk.IGNORED].includes(state)) {
+      return state;
+    }
+
+    return null;
+  }
+
+  static authStateFromNative(nativeAuthState) {
+    const state = nativeAuthState === null || nativeAuthState === void 0 ? void 0 : nativeAuthState.toLowerCase();
+
+    if ([MoveSdk.AUTH_VALID, MoveSdk.AUTH_EXPIRED].includes(state)) {
+      return state;
+    }
+
+    return null;
+  }
+
+  static configurationErrorFromNative(nativeInitError) {
+    const state = nativeInitError === null || nativeInitError === void 0 ? void 0 : nativeInitError.toLowerCase();
+    return state;
+  }
+
+  static initialize(config, auth, android) {
+    const {
+      timelineDetectionServices,
+      drivingServices,
+      walkingServices,
+      otherServices
+    } = config;
+    const {
+      contractId,
+      productId,
+      accessToken,
+      refreshToken
+    } = auth;
+    let platformParams = [];
+
+    if (_reactNative.Platform.OS === 'android') {
+      const {
+        notifications,
+        allowMockLocations
+      } = android;
+      const {
+        tripNotification,
+        recognitionNotification
+      } = notifications;
+
+      if (!tripNotification || !recognitionNotification) {
+        throw new Error('MOVE SDK needs notification configuration for Android');
+      }
+
+      platformParams = [recognitionNotification.title, recognitionNotification.text, recognitionNotification.channel.id, recognitionNotification.channel.name, recognitionNotification.channel.description, tripNotification.title, tripNotification.text, tripNotification.channel.id, tripNotification.channel.name, tripNotification.channel.description, allowMockLocations];
+    }
+
+    NativeMoveSdk.initialize(contractId, accessToken, refreshToken, productId, // Config
+    timelineDetectionServices, drivingServices, walkingServices, otherServices, // Platform config
+    ...platformParams).catch(e => {
+      throw new Error(`Initialization failed, Exception occured with message ${e.message}`);
+    });
+  }
+
+  static resolveError() {
+    NativeMoveSdk.resolveError();
+  }
+
+  static updateAuth(auth) {
+    const {
+      contractId,
+      productId,
+      accessToken,
+      refreshToken
+    } = auth;
+    NativeMoveSdk.updateAuth(contractId, accessToken, refreshToken, productId);
+  }
+
+  static startAutomaticDetection() {
+    NativeMoveSdk.startAutomaticDetection();
+  }
+
+  static forceTripRecognition() {
+    NativeMoveSdk.forceTripRecognition();
+  }
+
+  static keepInForeground(enabled) {
+    if (_reactNative.Platform.OS === 'android') {
+      NativeMoveSdk.keepInForeground(enabled);
+    } else {
+      console.warn('MoveSdk.keepInForeground() is Android OS only.');
+    }
+  }
+
+  static keepActive(enabled) {
+    if (_reactNative.Platform.OS === 'android') {
+      NativeMoveSdk.keepActive(enabled);
+    } else {
+      console.warn('MoveSdk.keepActive() is Android OS only.');
+    }
+  }
+
+  static stopAutomaticDetection() {
+    NativeMoveSdk.stopAutomaticDetection();
+  }
+
+  static synchronizeUserData() {
+    NativeMoveSdk.synchronizeUserData();
+  }
+
+  static shutdown() {
+    NativeMoveSdk.shutdown();
+  }
+
+  static getAuthState() {
+    return new Promise((resolve, _reject) => {
+      NativeMoveSdk.getAuthState().then(nativeState => resolve(MoveSdk.authStateFromNative(nativeState)));
+    });
+  }
+
+  static getState() {
+    return new Promise((resolve, _reject) => {
+      NativeMoveSdk.getState().then(nativeState => resolve(MoveSdk.sdkStateFromNative(nativeState)));
+    });
+  }
+
+  static getTripState() {
+    return new Promise((resolve, _reject) => {
+      NativeMoveSdk.getTripState().then(nativeState => resolve(MoveSdk.tripStateFromNative(nativeState)));
+    });
+  }
+
+  static addTripStateListener(tripStateChanged) {
+    return eventEmitter.addListener('DolphinSdk-TripState', event => tripStateChanged(MoveSdk.tripStateFromNative(event.state)));
+  }
+
+  static addSDKStateListener(sdkStateChanged) {
+    return eventEmitter.addListener('DolphinSdk-State', event => {
+      const transformedEvent = { ...event,
+        state: MoveSdk.sdkStateFromNative(event.state)
+      };
+      sdkStateChanged(transformedEvent);
+    });
+  }
+
+  static addInitErrorListener(initErrorReceived) {
+    return eventEmitter.addListener('DolphinSdk-InitError', event => initErrorReceived(MoveSdk.configurationErrorFromNative(event.error)));
+  }
+
+  static addAuthStateListener(authStateChanged) {
+    return eventEmitter.addListener('DolphinSdk-AuthState', event => {
+      const transformedEvent = { ...event,
+        state: MoveSdk.authStateFromNative(event.state)
+      };
+      authStateChanged(transformedEvent);
+    });
+  }
+
+  static addAppEventListener(appEventReceived) {
+    return eventEmitter.addListener('DolphinSdk-AppEvent', event => {
+      appEventReceived(event);
+    });
+  }
+
+  static version() {
+    return _reactNative.Platform.OS === 'android' ? NativeMoveSdk.getConstants().version : 'Unknown';
+  }
+
+  static finishCurrentTrip() {
+    NativeMoveSdk.finishCurrentTrip();
+  }
+
+  static ignoreCurrentTrip() {
+    NativeMoveSdk.ignoreCurrentTrip();
+  } // **** PERMISSIONS MODULE START *****
+
+
+  static canDrawOverlays() {
+    return new Promise((resolve, _reject) => {
+      NativeMoveSdk.canDrawOverlays().then(result => resolve(result));
+    });
+  }
+
+  static requestDrawOverlaysPermission() {
+    if (_reactNative.Platform.OS === 'android') {
+      NativeMoveSdk.requestDrawOverlaysPermission();
+    } else {
+      console.warn('MoveSdk.requestAppIgnoringBatteryOptimization() is Android OS only.');
+    }
+  }
+
+  static isAppIgnoringBatteryOptimization() {
+    return new Promise((resolve, _reject) => {
+      NativeMoveSdk.isAppIgnoringBatteryOptimization().then(result => resolve(result));
+    });
+  }
+
+  static requestAppIgnoringBatteryOptimization() {
+    if (_reactNative.Platform.OS === 'android') {
+      NativeMoveSdk.requestAppIgnoringBatteryOptimization();
+    } else {
+      console.warn('MoveSdk.requestAppIgnoringBatteryOptimization() is Android OS only.');
+    }
+  } // **** PERMISSIONS MODULE END *****
+
+
+}
+
+exports.default = MoveSdk;
+
+_defineProperty(MoveSdk, "ERROR", 'error');
+
+_defineProperty(MoveSdk, "READY", 'ready');
+
+_defineProperty(MoveSdk, "RUNNING", 'running');
+
+_defineProperty(MoveSdk, "UNINITIALIZED", 'uninitialized');
+
+_defineProperty(MoveSdk, "AUTH_INVALID", 'authinvalid');
+
+_defineProperty(MoveSdk, "AUTH_EXPIRED", 'expired');
+
+_defineProperty(MoveSdk, "AUTH_VALID", 'valid');
+
+_defineProperty(MoveSdk, "UNKNOWN", 'unknown');
+
+_defineProperty(MoveSdk, "DRIVING", 'driving');
+
+_defineProperty(MoveSdk, "HALT", 'halt');
+
+_defineProperty(MoveSdk, "IDLE", 'idle');
+
+_defineProperty(MoveSdk, "IGNORED", 'ignored');
+//# sourceMappingURL=index.js.map