react-native-spike-sdk 4.0.13-beta.2 → 4.0.13-beta.3

package/android/build.gradle

@@ -76,7 +76,7 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-android:0.71.3"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation 'com.spikeapi.sdk:spike-sdk:3.1.6'
+  implementation 'com.spikeapi.sdk:spike-sdk:4.0.12-beta.1'
   implementation 'androidx.core:core-ktx:1.9.0'
   implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.5.1'
   implementation 'com.google.code.gson:gson:2.10.1'

package/android/src/main/java/com/spikesdk/SpikeSdkModule.kt

@@ -14,6 +14,12 @@ import com.spikeapi.SpikeExceptions
 import com.spikeapi.SpikeLogger
 import com.spikeapi.SpikePackageChecker
 import com.spikeapi.healthconnect.HealthConnectAvailability
+import com.spikeapi.apiv3.SpikeConnectionAPIv3
+import com.spikeapi.apiv3.datamodels.MetricType
+import com.spikeapi.apiv3.datamodels.StatisticsType
+import com.spikeapi.apiv3.datamodels.StatisticsInterval
+import com.spikeapi.apiv3.datamodels.StatisticsFilter
+import com.spikeapi.apiv3.healthconnect.HealthConnectPermissionManager
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -22,6 +28,10 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import java.time.OffsetDateTime
 import java.util.UUID
+import android.util.Log
+import java.time.Instant
+import java.time.format.DateTimeParseException
+
 
 fun <I, O> ComponentActivity.registerActivityResultLauncher(
     contract: ActivityResultContract<I, O>,
@@ -513,7 +523,9 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
             .emit(eventName, params)
     }
+
     override fun onHostResume() {
+        // Old SDK
         checkPermissionsFor?.let {
             it.second.forEach { permission ->
                 checkPermissionsGranted(
@@ -524,6 +536,12 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
             }
         }
         checkPermissionsFor = null
+
+        // New SDK V3
+        checkPermissionsForV3?.let {
+            areAllPermissionsGranted(it.first, it.second, it.third)
+        }
+        checkPermissionsForV3 = null
     }
 
     override fun onHostPause() {
@@ -554,4 +572,375 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    // ------------------------- V3 -------------------------
+    
+    @ReactMethod
+    fun setWrapper(type: String, version: String) {
+        SpikeConnectionAPIv3.setWrapper(type, version)
+    }
+
+    @ReactMethod
+    fun createConnectionAPIv3(
+        uuid: String,
+        appId: String,
+        authToken: String,
+        customerEndUserId: String,
+        promise: Promise
+    ) {
+        scope.launch {
+            try {
+                val connection = SpikeConnectionAPIv3.createConnection(
+                    appId = appId,
+                    authToken = authToken,
+                    customerEndUserId = customerEndUserId,
+                    context = reactApplicationContext
+                )
+
+                addConnectionV3(connection, uuid)
+                promise.resolve(uuid)
+
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    /// --- Read Health connect data ---
+
+    @ReactMethod
+    fun getStatisticsconnectionUUID(
+        connectionUUID: String,
+        types: ReadableArray, // [StatisticsType]
+        from: String, // Instant
+        to: String, // Instant
+        interval: String, // StatisticsInterval
+        filter: String?, // StatisticsFilter?
+        promise: Promise
+    ) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                "Connection not found (enableHealthConnectIntegration)"
+            )
+            val statTypes = types.toArrayList().mapNotNull {
+                StatisticsType.fromValue(it as String)
+            }.toSet()
+            val dateFrom = convertIsoStringToInstant(from)
+            val dateTo = convertIsoStringToInstant(to)
+            val statsInterval = StatisticsInterval.fromValue(interval)
+            val statsFilter = StatisticsFilter.fromValue(filter)
+
+            val result = connection.getStatistics(
+                types = statTypes,
+                from = dateFrom,
+                to = dateTo,
+                interval = statsInterval,
+                filter = statsFilter
+            )
+
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        }
+    }
+
+    @ReactMethod
+    fun getRecordsconnectionUUID(
+        connectionUUID: String,
+        types: ReadableArray, // [MetricType]
+        from: String, // Instant
+        to: String, // Instant
+        filter: String?, // StatisticsFilter?
+        promise: Promise
+    ) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                "Connection not found (enableHealthConnectIntegration)"
+            )
+            val statTypes = types.toArrayList().mapNotNull {
+                MetricType.fromValue(it as String)
+            }.toSet()
+            val dateFrom = convertIsoStringToInstant(from)
+            val dateTo = convertIsoStringToInstant(to)
+            val statsFilter = StatisticsFilter.fromValue(filter)
+
+            val result = connection.getRecords(
+                types = statTypes,
+                from = dateFrom,
+                to = dateTo,
+                filter = statsFilter
+            )
+
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        }
+    }
+
+    /// --- Health connect permissions ---
+
+    @ReactMethod
+    fun checkHealthConnectAvailability(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                "Connection not found (checkHealthConnectAvailability)"
+            )
+
+            val result = connection.checkHealthConnectAvailability()
+            promise.resolve(result.value)
+        }
+    }
+
+    @ReactMethod
+    fun openHealthConnectInstallation(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                "Connection not found (openHealthConnectInstallation)"
+            )
+
+            connection.openHealthConnectInstallation()
+            promise.resolve(true)
+        }
+    }
+
+    @ReactMethod
+    fun enableHealthConnectIntegration(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                "Connection not found (enableHealthConnectIntegration)"
+            )
+
+            connection.enableHealthConnectIntegration()
+            Log.d("SpikeSdkModule", "Health Connect integration enabled")
+            promise.resolve(true)
+        }
+    }
+
+    @ReactMethod
+    fun disableHealthConnectIntegration(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                "Connection not found (enableHealthConnectIntegration)"
+            )
+
+            connection.disableHealthConnectIntegration()
+            Log.d("SpikeSdkModule", "Health Connect integration disabled")
+            promise.resolve(true)
+        }
+    }
+
+    @ReactMethod
+    fun isHealthConnectIntegrationEnabled(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                "Connection not found (enableHealthConnectIntegration)"
+            )
+
+            val result = connection.isHealthConnectIntegrationEnabled()
+            Log.d("SpikeSdkModule", "Health Connect integration is " + if (result) { "enabled" } else ( "disabled" ))
+            promise.resolve(result)
+        }
+    }
+
+    @ReactMethod
+    fun getGrantedHealthKitPermissions(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                "Connection not found (getGrantedHealthKitPermissions)"
+            )
+            if (!connection.isHealthConnectIntegrationEnabled()) {
+                return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
+                    "Health Connect should be enabled before calling getGrantedHealthKitPermissions"
+                )
+            }
+
+            val permissions = connection
+                .getHealthConnectPermissionManager()
+                .getGrantedPermissions()
+
+            val result = Arguments.createArray()
+            permissions.forEach {
+                result.pushString(it)
+            }
+            
+            Log.w("SpikeSdkModule", "$permissions")
+            promise.resolve(result)
+        }
+    }
+
+    @ReactMethod
+    fun getHealthConnectPermissionsForStatisticTypes(connectionUUID: String, statisticTypes: ReadableArray, promise: Promise) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                "Connection not found (getPermissionsForHealthConnect)"
+            )
+            if (!connection.isHealthConnectIntegrationEnabled()) {
+                return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
+                    "Health Connect should be enabled before calling getHealthConnectPermissionsForStatisticTypes"
+                )
+            }
+            val permissionManager = connection.getHealthConnectPermissionManager()
+
+            val statTypes = statisticTypes.toArrayList().mapNotNull {
+                StatisticsType.fromValue(it as String)
+            }.toSet()
+
+            val permissions = permissionManager
+                .getPermissionsForStatistics(statisticsTypes = statTypes)
+
+            val result = Arguments.createArray()
+            permissions.forEach {
+                result.pushString(it)
+            }
+            
+            // Log.w("SpikeSdkModule", "$permissions")
+            promise.resolve(result)
+        }
+    }
+
+    @ReactMethod
+    fun revokeAllHealthConnectPermissions(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException("Connection not found").mapException(), 
+                "Connection not found (revokeAllHealthConnectPermissions)"
+            )
+            if (!connection.isHealthConnectIntegrationEnabled()) {
+                return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
+                    "Health Connect should be enabled before calling revokeAllHealthConnectPermissions"
+                )
+            }
+
+            connection
+                .getHealthConnectPermissionManager()
+                .revokeAllPermissions()
+            
+            promise.resolve(true)
+        }
+    }
+
+    @ReactMethod
+    fun requestPermissionsFromHealthConnect(connectionUUID: String, permissions: ReadableArray, promise: Promise) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException(
+                    "Connection not found"
+                ).mapException(), "Connection not found"
+            )
+            if (!connection.isHealthConnectIntegrationEnabled()) {
+                return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
+                    "Health Connect should be enabled before calling requestPermissionsFromHealthConnect"
+                )
+            }
+
+            val permissionManager = connection.getHealthConnectPermissionManager()
+            val permissionsStrings = permissions.toArrayList().map{ it as String }.toSet()
+
+            if (checkIfAllPermissionsAreGranted(permissionManager, permissionsStrings)) {
+                // All permissions granted, nothing to do here
+                promise.resolve(true)
+                return@launch
+            }
+            
+            Log.d("SpikeSdkModule", "Will ask for following Health Connect permissions: $permissions")
+
+            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.TIRAMISU) {
+                startHealthConnectRequest_oldAndroid(connectionUUID, permissionManager, permissionsStrings, promise)
+            } else {
+                startHealthConnectRequest(connectionUUID, permissionManager, permissionsStrings, promise)
+            }
+        }
+    }
+
+    private fun startHealthConnectRequest_oldAndroid(connectionUUID: String, permissionManager: HealthConnectPermissionManager, permissions: Set<String>, promise: Promise) {
+        // val availability = connection.getHealthConnectAvailability()
+        //  && availability == HealthConnectAvailability.INSTALLED
+        val intent = permissionManager.getRequestPermissionResultContract().createIntent(
+            reactApplicationContext, permissions
+        )
+
+        reactApplicationContext.currentActivity?.startActivityForResult(
+            intent,
+            REQUEST_CODE
+        )
+        promise.resolve(true)
+    }
+
+    private var checkPermissionsForV3: Triple<String, Set<String>, Promise>? = null
+
+    private fun startHealthConnectRequest(connectionUUID: String, permissionManager: HealthConnectPermissionManager, permissions: Set<String>, promise: Promise) {
+        val activity = reactApplicationContext.currentActivity
+        if (!(activity is ComponentActivity)) {
+            promise.resolve(false)
+            return
+        }
+        checkPermissionsForV3 = Triple(
+            connectionUUID,
+            permissions,
+            promise
+        )
+        val launcher = activity.registerActivityResultLauncher(permissionManager.getRequestPermissionResultContract()) {
+
+        }
+        launcher.launch(permissions) 
+    }
+
+    @ReactMethod
+    fun areAllPermissionsGranted(connectionUUID: String, permissions: Set<String>, promise: Promise) {
+        scope.launch {
+            val connection = getConnectionV3(connectionUUID) ?: return@launch promise.reject(
+                SpikeExceptions.SpikeException(
+                    "Connection not found"
+                ).mapException(), "Connection not found"
+            )
+            if (!connection.isHealthConnectIntegrationEnabled()) {
+                return@launch promise.reject(
+                    SpikeExceptions.SpikeException("Health Connect is disabled").mapException(), 
+                    "Health Connect should be enabled before calling areAllPermissionsGranted"
+                )
+            }
+            val permissionManager = connection.getHealthConnectPermissionManager()
+
+            val permissionsGranted: Boolean = checkIfAllPermissionsAreGranted(permissionManager, permissions)
+            promise.resolve(permissionsGranted)
+        }
+    }
+
+    private suspend fun checkIfAllPermissionsAreGranted(permissionManager: HealthConnectPermissionManager, permissions: Set<String>): Boolean {
+        return permissionManager.getGrantedPermissions().containsAll(permissions)
+    }
+
+    /// --- Private stuff ---
+
+    // Do not use this directly, use `addConnection` and `getConnection` instead
+    private val _connectionsV3 = mutableMapOf<String, SpikeConnectionAPIv3>()
+
+    private val mutexV3 = Mutex()
+
+    // Add new connection to the dictionary in a thread-safe manner
+    private suspend fun addConnectionV3(connection: SpikeConnectionAPIv3, uuid: String) {
+        mutex.withLock {
+            _connectionsV3[uuid] = connection
+        }
+    }
+
+    // Synchronised read for safe multithreaded usage
+    private suspend fun getConnectionV3(uuid: String): SpikeConnectionAPIv3? {
+        mutex.withLock {
+            return _connectionsV3[uuid]
+        }
+    }
+
 }
+
+private fun convertIsoStringToInstant(isoString: String): Instant {
+    return Instant.parse(isoString)
+}

package/ios/SpikeExceptionMapper.swift

@@ -37,6 +37,8 @@ class SpikeExceptionMapper {
              return "SpikeDataExtractionException"
          case is SpikeDataDecodingException:
              return "SpikeDataDecodingException"
+         case is SpikeApiException:
+             return "SpikeApiException"
          default:
              return "SpikeException"
          }

package/lib/commonjs/SpikeException.js

@@ -98,6 +98,8 @@ const unwrapSpikeException = error => {
         return new SpikeException("SpikeConnectionNotFoundException");
       case 'SpikeDataDecodingException':
         return new SpikeException("SpikeDataDecodingException:" + error.message);
+      case 'SpikeApiException':
+        return new SpikeException(error.message);
       default:
         return new SpikeException("Default SpikeException: " + error.message);
     }

package/lib/commonjs/SpikeException.js.map

@@ -1 +1 @@
-{"version":3,"names":["SpikeException","Error","constructor","message","exports","SpikeConnectionIsClosedException","SpikeInvalidCredentialsException","SpikeInvalidDateRangeException","SpikeInvalidCallbackUrlException","SpikePackException","SpikePermissionsNotGrantedException","SpikeServerException","SpikeUnpackException","SpikeCallbackURLNotProvidedException","SpikeHealthDataNotAvailableException","unwrapSpikeException","error","code"],"sourceRoot":"../../src","sources":["SpikeException.ts"],"mappings":";;;;;;AAAO,MAAMA,cAAc,SAASC,KAAK,CAAC;EACxCC,WAAWA,CAACC,OAAgB,EAAE;IAC5B,KAAK,CAACA,OAAO,IAAI,gBAAgB,CAAC;EACpC;AACF;AAACC,OAAA,CAAAJ,cAAA,GAAAA,cAAA;AAEM,MAAMK,gCAAgC,SAASL,cAAc,CAAC;EACnEE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,kCAAkC,CAAC;EAC3C;AACF;AAACE,OAAA,CAAAC,gCAAA,GAAAA,gCAAA;AACM,MAAMC,gCAAgC,SAASN,cAAc,CAAC;EACnEE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,kCAAkC,CAAC;EAC3C;AACF;AAACE,OAAA,CAAAE,gCAAA,GAAAA,gCAAA;AACM,MAAMC,8BAA8B,SAASP,cAAc,CAAC;EACjEE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,gCAAgC,CAAC;EACzC;AACF;AAACE,OAAA,CAAAG,8BAAA,GAAAA,8BAAA;AACM,MAAMC,gCAAgC,SAASR,cAAc,CAAC;EACnEE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,kCAAkC,CAAC;EAC3C;AACF;AAACE,OAAA,CAAAI,gCAAA,GAAAA,gCAAA;AACM,MAAMC,kBAAkB,SAAST,cAAc,CAAC;EACrDE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,oBAAoB,CAAC;EAC7B;AACF;AAACE,OAAA,CAAAK,kBAAA,GAAAA,kBAAA;AACM,MAAMC,mCAAmC,SAASV,cAAc,CAAC;EACtEE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,qCAAqC,CAAC;EAC9C;AACF;AAACE,OAAA,CAAAM,mCAAA,GAAAA,mCAAA;AACM,MAAMC,oBAAoB,SAASX,cAAc,CAAC;EACvDE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,sBAAsB,CAAC;EAC/B;AACF;AAACE,OAAA,CAAAO,oBAAA,GAAAA,oBAAA;AACM,MAAMC,oBAAoB,SAASZ,cAAc,CAAC;EACvDE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,sBAAsB,CAAC;EAC/B;AACF;AAACE,OAAA,CAAAQ,oBAAA,GAAAA,oBAAA;AACM,MAAMC,oCAAoC,SAASb,cAAc,CAAC;EACvEE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,sCAAsC,CAAC;EAC/C;AACF;AAACE,OAAA,CAAAS,oCAAA,GAAAA,oCAAA;AACM,MAAMC,oCAAoC,SAASd,cAAc,CAAC;EACvEE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,sCAAsC,CAAC;EAC/C;AACF;AAACE,OAAA,CAAAU,oCAAA,GAAAA,oCAAA;AAEM,MAAMC,oBAAoB,GAAIC,KAAc,IAAqB;EACtE,IAAIA,KAAK,YAAYf,KAAK,IAAI,MAAM,IAAIe,KAAK,EAAE;IAC7C,QAAQA,KAAK,CAACC,IAAI;MAChB,KAAK,kCAAkC;QACrC,OAAO,IAAIZ,gCAAgC,CAAC,CAAC;MAE/C,KAAK,kCAAkC;QACrC,OAAO,IAAIC,gCAAgC,CAAC,CAAC;MAE/C,KAAK,gCAAgC;QACnC,OAAO,IAAIC,8BAA8B,CAAC,CAAC;MAE7C,KAAK,kCAAkC;QACrC,OAAO,IAAIC,gCAAgC,CAAC,CAAC;MAE/C,KAAK,oBAAoB;QACvB,OAAO,IAAIC,kBAAkB,CAAC,CAAC;MAEjC,KAAK,qCAAqC;QACxC,OAAO,IAAIC,mCAAmC,CAAC,CAAC;MAElD,KAAK,sBAAsB;QACzB,OAAO,IAAIC,oBAAoB,CAAC,CAAC;MAEnC,KAAK,sBAAsB;QACzB,OAAO,IAAIC,oBAAoB,CAAC,CAAC;MAEnC,KAAK,sCAAsC;QACzC,OAAO,IAAIC,oCAAoC,CAAC,CAAC;MAEnD,KAAK,sCAAsC;QACzC,OAAO,IAAIC,oCAAoC,CAAC,CAAC;MAEnD,KAAK,kCAAkC;QAAE;QACvC,OAAO,IAAId,cAAc,CAAC,kCAAkC,CAAC;MAE/D,KAAK,4BAA4B;QAC/B,OAAO,IAAIA,cAAc,CAAC,6BAA6B,GAAGgB,KAAK,CAACb,OAAO,CAAC;MAE1E;QACE,OAAO,IAAIH,cAAc,CAAC,0BAA0B,GAAGgB,KAAK,CAACb,OAAO,CAAC;IACzE;EACF;EACA,OAAO,IAAIH,cAAc,CAAC,0BAA0B,GAAGgB,KAAK,CAAC;AAC/D,CAAC;AAACZ,OAAA,CAAAW,oBAAA,GAAAA,oBAAA","ignoreList":[]}
+{"version":3,"names":["SpikeException","Error","constructor","message","exports","SpikeConnectionIsClosedException","SpikeInvalidCredentialsException","SpikeInvalidDateRangeException","SpikeInvalidCallbackUrlException","SpikePackException","SpikePermissionsNotGrantedException","SpikeServerException","SpikeUnpackException","SpikeCallbackURLNotProvidedException","SpikeHealthDataNotAvailableException","unwrapSpikeException","error","code"],"sourceRoot":"../../src","sources":["SpikeException.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/index.js

@@ -15,6 +15,12 @@ Object.defineProperty(exports, "ActivityType", {
     return _ActivityType.ActivityType;
   }
 });
+Object.defineProperty(exports, "HealthConnectAvailabilityStatus", {
+  enumerable: true,
+  get: function () {
+    return _HealthConnectAvailabilityStatus.HealthConnectAvailabilityStatus;
+  }
+});
 Object.defineProperty(exports, "InputMethod", {
   enumerable: true,
   get: function () {
@@ -163,6 +169,7 @@ var _StatisticsType = require("./v3/DataModels/StatisticsType");
 var _StatisticsInterval = require("./v3/DataModels/StatisticsInterval");
 var _Unit = require("./v3/DataModels/Unit");
 var _StatisticsFilter = require("./v3/StatisticsFilter");
+var _HealthConnectAvailabilityStatus = require("./v3/DataModels/HealthConnectAvailabilityStatus");
 var _default = exports.default = {
   createConnection: _Spike.createConnection,
   getBackgroundConnections: _Spike.getBackgroundConnections,

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_SpikeDataTypes","require","_Spike","_SpikeConnection","_SpikeException","_SpikeRNConnectionAPIv","_ActivityTag","_ActivityType","_InputMethod","_MetricType","_Provider","_ProviderSource","_StatisticsType","_StatisticsInterval","_Unit","_StatisticsFilter","_default","exports","default","createConnection","getBackgroundConnections","ensurePermissionsAreGranted","isPackageInstalled","isHealthDataAvailable","createConnectionAPIv3"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AASA,IAAAE,gBAAA,GAAAF,OAAA;AAIA,IAAAG,eAAA,GAAAH,OAAA;AAkEA,IAAAI,sBAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA;AACA,IAAAM,aAAA,GAAAN,OAAA;AACA,IAAAO,YAAA,GAAAP,OAAA;AACA,IAAAQ,WAAA,GAAAR,OAAA;AACA,IAAAS,SAAA,GAAAT,OAAA;AACA,IAAAU,eAAA,GAAAV,OAAA;AACA,IAAAW,eAAA,GAAAX,OAAA;AACA,IAAAY,mBAAA,GAAAZ,OAAA;AACA,IAAAa,KAAA,GAAAb,OAAA;AACA,IAAAc,iBAAA,GAAAd,OAAA;AAAyD,IAAAe,QAAA,GAAAC,OAAA,CAAAC,OAAA,GApD1C;EACbC,gBAAgB,EAAhBA,uBAAgB;EAChBC,wBAAwB,EAAxBA,+BAAwB;EACxBC,2BAA2B,EAA3BA,kCAA2B;EAC3BC,kBAAkB,EAAlBA,yBAAkB;EAClBC,qBAAqB,EAArBA,4BAAqB;EACrB;EACAC,qBAAqB,EAArBA;AACF,CAAC,EAiCD","ignoreList":[]}
+{"version":3,"names":["_SpikeDataTypes","require","_Spike","_SpikeConnection","_SpikeException","_SpikeRNConnectionAPIv","_ActivityTag","_ActivityType","_InputMethod","_MetricType","_Provider","_ProviderSource","_StatisticsType","_StatisticsInterval","_Unit","_StatisticsFilter","_HealthConnectAvailabilityStatus","_default","exports","default","createConnection","getBackgroundConnections","ensurePermissionsAreGranted","isPackageInstalled","isHealthDataAvailable","createConnectionAPIv3"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AASA,IAAAE,gBAAA,GAAAF,OAAA;AAIA,IAAAG,eAAA,GAAAH,OAAA;AAkEA,IAAAI,sBAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA;AACA,IAAAM,aAAA,GAAAN,OAAA;AACA,IAAAO,YAAA,GAAAP,OAAA;AACA,IAAAQ,WAAA,GAAAR,OAAA;AACA,IAAAS,SAAA,GAAAT,OAAA;AACA,IAAAU,eAAA,GAAAV,OAAA;AACA,IAAAW,eAAA,GAAAX,OAAA;AACA,IAAAY,mBAAA,GAAAZ,OAAA;AACA,IAAAa,KAAA,GAAAb,OAAA;AACA,IAAAc,iBAAA,GAAAd,OAAA;AACA,IAAAe,gCAAA,GAAAf,OAAA;AAAkG,IAAAgB,QAAA,GAAAC,OAAA,CAAAC,OAAA,GArDnF;EACbC,gBAAgB,EAAhBA,uBAAgB;EAChBC,wBAAwB,EAAxBA,+BAAwB;EACxBC,2BAA2B,EAA3BA,kCAA2B;EAC3BC,kBAAkB,EAAlBA,yBAAkB;EAClBC,qBAAqB,EAArBA,4BAAqB;EACrB;EACAC,qBAAqB,EAArBA;AACF,CAAC,EAiCD","ignoreList":[]}

package/lib/commonjs/v3/DataModels/HealthConnectAvailabilityStatus.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HealthConnectAvailabilityStatus = void 0;
+let HealthConnectAvailabilityStatus = exports.HealthConnectAvailabilityStatus = /*#__PURE__*/function (HealthConnectAvailabilityStatus) {
+  HealthConnectAvailabilityStatus["notInstalled"] = "NOT_INSTALLED";
+  HealthConnectAvailabilityStatus["updateRequired"] = "UPDATE_REQUIRED";
+  HealthConnectAvailabilityStatus["installed"] = "INSTALLED";
+  return HealthConnectAvailabilityStatus;
+}({});
+//# sourceMappingURL=HealthConnectAvailabilityStatus.js.map

package/lib/commonjs/v3/DataModels/HealthConnectAvailabilityStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["HealthConnectAvailabilityStatus","exports"],"sourceRoot":"../../../../src","sources":["v3/DataModels/HealthConnectAvailabilityStatus.ts"],"mappings":";;;;;;IACYA,+BAA+B,GAAAC,OAAA,CAAAD,+BAAA,0BAA/BA,+BAA+B;EAA/BA,+BAA+B;EAA/BA,+BAA+B;EAA/BA,+BAA+B;EAAA,OAA/BA,+BAA+B;AAAA","ignoreList":[]}