react-native-spike-sdk 4.3.53 → 4.3.73-beta.1

package/android/build.gradle

@@ -9,7 +9,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:7.2.1"
+    classpath "com.android.tools.build:gradle:8.6.0"
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
@@ -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:4.2.82'
+  implementation 'com.spikeapi.sdk:spike-sdk:4.3.12'
   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

@@ -1026,8 +1026,11 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         promise: Promise
     ) {
         executeV3MethodWithConnection("enableBackgroundDelivery", connectionUUID, promise) { connection ->
-            if (!connection.isHealthConnectIntegrationEnabled()) {
-                throw SpikeExceptions.SpikeException("Health Connect should be enabled before calling enableBackgroundDelivery")
+            val healthConnectEnabled = connection.isHealthConnectIntegrationEnabled()
+            val samsungHealthDataEnabled = connection.isSamsungHealthDataIntegrationEnabled()
+            
+            if (!healthConnectEnabled && !samsungHealthDataEnabled) {
+                throw SpikeExceptions.SpikeException("Either Health Connect or Samsung Health Data should be enabled before calling enableBackgroundDelivery")
             }
 
             val statTypes = statisticTypes.toArrayList().mapNotNull {
@@ -1063,8 +1066,11 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         promise: Promise
     ) {
         executeV3MethodWithConnection("disableBackgroundDelivery", connectionUUID, promise) { connection ->
-            if (!connection.isHealthConnectIntegrationEnabled()) {
-                throw SpikeExceptions.SpikeException("Health Connect should be enabled before calling disableBackgroundDelivery")
+            val healthConnectEnabled = connection.isHealthConnectIntegrationEnabled()
+            val samsungHealthDataEnabled = connection.isSamsungHealthDataIntegrationEnabled()
+            
+            if (!healthConnectEnabled && !samsungHealthDataEnabled) {
+                throw SpikeExceptions.SpikeException("Either Health Connect or Samsung Health Data should be enabled before calling disableBackgroundDelivery")
             }
             connection.disableBackgroundDelivery()
             promise.resolve(true)
@@ -1077,8 +1083,11 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         promise: Promise
     ) {
         executeV3MethodWithConnection("getBackgroundDeliveryConfig", connectionUUID, promise) { connection ->
-            if (!connection.isHealthConnectIntegrationEnabled()) {
-                throw SpikeExceptions.SpikeException("Health Connect should be enabled before calling getBackgroundDeliveryConfig")
+            val healthConnectEnabled = connection.isHealthConnectIntegrationEnabled()
+            val samsungHealthDataEnabled = connection.isSamsungHealthDataIntegrationEnabled()
+            
+            if (!healthConnectEnabled && !samsungHealthDataEnabled) {
+                throw SpikeExceptions.SpikeException("Either Health Connect or Samsung Health Data should be enabled before calling getBackgroundDeliveryConfig")
             }
             val result = connection.getBackgroundDeliveryConfig()
             if (result == null) {
@@ -1148,6 +1157,183 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    /// --- Samsung Health Data permissions ---
+
+    @ReactMethod
+    fun checkSamsungHealthDataAvailability(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("checkSamsungHealthDataAvailability", connectionUUID, promise) { connection ->
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                throw SpikeExceptions.SpikeException("Activity is required to check Samsung Health Data availability")
+            }
+            val result = connection.checkSamsungHealthDataAvailability(activity)
+            promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
+        }
+    }
+
+    @ReactMethod
+    fun enableSamsungHealthDataIntegration(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("enableSamsungHealthDataIntegration", connectionUUID, promise) { connection ->
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                throw SpikeExceptions.SpikeException("Activity is required to enable Samsung Health Data integration")
+            }
+            connection.enableSamsungHealthDataIntegration(activity)
+            Log.d("SpikeSdkModule", "Samsung Health Data integration enabled")
+            promise.resolve(true)
+        }
+    }
+
+    @ReactMethod
+    fun disableSamsungHealthDataIntegration(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("disableSamsungHealthDataIntegration", connectionUUID, promise) { connection ->
+            connection.disableSamsungHealthDataIntegration()
+            Log.d("SpikeSdkModule", "Samsung Health Data integration disabled")
+            promise.resolve(true)
+        }
+    }
+
+    @ReactMethod
+    fun isSamsungHealthDataIntegrationEnabled(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("isSamsungHealthDataIntegrationEnabled", connectionUUID, promise) { connection ->
+            val result = connection.isSamsungHealthDataIntegrationEnabled()
+            Log.d("SpikeSdkModule", "Samsung Health Data integration is " + if (result) { "enabled" } else ( "disabled" ))
+            promise.resolve(result)
+        }
+    }
+
+    @ReactMethod
+    fun getGrantedSamsungHealthDataPermissions(connectionUUID: String, promise: Promise) {
+        executeV3MethodWithConnection("getGrantedSamsungHealthDataPermissions", connectionUUID, promise) { connection ->
+            if (!connection.isSamsungHealthDataIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("Samsung Health Data should be enabled before calling getGrantedSamsungHealthDataPermissions")
+            }
+
+            val permissions = connection
+                .getSamsungHealthDataPermissionManager()
+                .getGrantedPermissions()
+
+            val result = Arguments.createArray()
+            permissions.forEach {
+                result.pushString(it)
+            }
+            
+            Log.w("SpikeSdkModule", "$permissions")
+            promise.resolve(result)
+        }
+    }
+
+    @ReactMethod
+    fun getSamsungHealthDataPermissions(
+        connectionUUID: String, 
+        statisticTypes: ReadableArray, 
+        metricTypes: ReadableArray, 
+        activityConfigs: ReadableArray, 
+        sleepConfigs: ReadableArray, 
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("getSamsungHealthDataPermissions", connectionUUID, promise) { connection ->
+            if (!connection.isSamsungHealthDataIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("Samsung Health Data should be enabled before calling getSamsungHealthDataPermissions")
+            }
+            val permissionManager = connection.getSamsungHealthDataPermissionManager()
+
+            val statTypes = statisticTypes.toArrayList().mapNotNull {
+                StatisticsTypeUtils.fromValue(it as String)
+            }.toSet()
+
+            val mTypes = metricTypes.toArrayList().mapNotNull {
+                MetricTypeUtils.fromValue(it as String)
+            }.toSet()
+
+            val aConfigs = activityConfigs.toArrayList().mapNotNull {
+                ActivityConfigUtils.fromValue(it as String)
+            }.toSet()
+
+            val sConfigs = sleepConfigs.toArrayList().mapNotNull {
+                SleepConfigUtils.fromValue(it as String)
+            }.toSet()
+
+            val permissions = permissionManager
+                .getPermissions(
+                    statisticsTypes = statTypes,
+                    metricTypes = mTypes,
+                    activityConfigs = aConfigs,
+                    sleepConfigs = sConfigs
+                )
+
+            val result = Arguments.createArray()
+            permissions.forEach {
+                result.pushString(it)
+            }
+            
+            promise.resolve(result)
+        }
+    }
+
+    @ReactMethod
+    fun requestPermissionsFromSamsungHealthData(
+        connectionUUID: String, 
+        statisticTypes: ReadableArray, 
+        metricTypes: ReadableArray, 
+        activityConfigs: ReadableArray, 
+        sleepConfigs: ReadableArray, 
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("requestPermissionsFromSamsungHealthData", connectionUUID, promise) { connection ->
+            if (!connection.isSamsungHealthDataIntegrationEnabled()) {
+                throw SpikeExceptions.SpikeException("Samsung Health Data should be enabled before calling requestPermissionsFromSamsungHealthData")
+            }
+
+            val permissionManager = connection.getSamsungHealthDataPermissionManager()
+
+            val statTypes = statisticTypes.toArrayList().mapNotNull {
+                StatisticsTypeUtils.fromValue(it as String)
+            }.toSet()
+
+            val mTypes = metricTypes.toArrayList().mapNotNull {
+                MetricTypeUtils.fromValue(it as String)
+            }.toSet()
+
+            val aConfigs = activityConfigs.toArrayList().mapNotNull {
+                ActivityConfigUtils.fromValue(it as String)
+            }.toSet()
+
+            val sConfigs = sleepConfigs.toArrayList().mapNotNull {
+                SleepConfigUtils.fromValue(it as String)
+            }.toSet()
+            
+            Log.d("SpikeSdkModule", "Will ask for Samsung Health Data permissions with: statTypes=$statTypes, metricTypes=$mTypes, activityConfigs=$aConfigs, sleepConfigs=$sConfigs")
+
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                throw SpikeExceptions.SpikeException("Activity is required to request Samsung Health Data permissions")
+            }
+
+            try {
+                val grantedPermissions = permissionManager.requestPermissions(
+                    statisticsTypes = statTypes,
+                    metricTypes = mTypes,
+                    activityConfigs = aConfigs,
+                    sleepConfigs = sConfigs
+                )
+                
+                val result = Arguments.createArray()
+                grantedPermissions.forEach {
+                    result.pushString(it)
+                }
+                
+                promise.resolve(result)
+            } catch (e: Exception) {
+                promise.reject(e.toString(), e.message)
+            }
+        }
+    }
+
+
+
+    /// --- 
+
 }
 
 private fun convertIsoStringToInstant(isoString: String): Instant {

package/app.plugin.js

@@ -1,21 +1,29 @@
 const {
   withEntitlementsPlist,
   withInfoPlist,
+  withProjectBuildGradle,
+  withAndroidManifest,
 } = require('@expo/config-plugins');
 
-const HEALTH_SHARE = 'Allow $(PRODUCT_NAME) to check health info';
-const HEALTH_UPDATE = 'Allow $(PRODUCT_NAME) to update health info';
-const HEALTH_CLINIC_SHARE =
-  'Allow $(PRODUCT_NAME) to check health clinical info';
+// Default permission descriptions - these are used as fallbacks if no custom descriptions are provided
+const DEFAULT_HEALTH_SHARE_DESCRIPTION = 'Allow $(PRODUCT_NAME) to check health info';
+const DEFAULT_HEALTH_UPDATE_DESCRIPTION = 'Allow $(PRODUCT_NAME) to update health info';
 
+/**
+ * Configures HealthKit permissions and entitlements for iOS
+ * @param {Object} config - Expo config object
+ * @param {Object} options - Configuration options
+ * @param {string} [options.healthSharePermission] - Custom description for health share permission (NSHealthShareUsageDescription)
+ * @param {string} [options.healthUpdatePermission] - Custom description for health update permission (NSHealthUpdateUsageDescription)
+ * @param {boolean} [options.isBackgroundDeliveryEnabled=true] - Whether to enable background health data deliveries (defaults to true)
+ * @returns {Object} Modified config object
+ */
 const withSpikeHealthKit = (
   config,
   {
     healthSharePermission,
     healthUpdatePermission,
-    isClinicalDataEnabled,
-    healthClinicalDescription,
-    isBackgroundDeliveriesEnabled,
+    isBackgroundDeliveryEnabled = true,
   } = {}
 ) => {
   // Add permissions
@@ -23,18 +31,11 @@ const withSpikeHealthKit = (
     config.modResults.NSHealthShareUsageDescription =
       healthSharePermission ||
       config.modResults.NSHealthShareUsageDescription ||
-      HEALTH_SHARE;
+      DEFAULT_HEALTH_SHARE_DESCRIPTION;
     config.modResults.NSHealthUpdateUsageDescription =
       healthUpdatePermission ||
       config.modResults.NSHealthUpdateUsageDescription ||
-      HEALTH_UPDATE;
-    isClinicalDataEnabled
-      ? (config.modResults.NSHealthClinicalHealthRecordsShareUsageDescription =
-          healthClinicalDescription ||
-          config.modResults
-            .NSHealthClinicalHealthRecordsShareUsageDescription ||
-          HEALTH_CLINIC_SHARE)
-      : null;
+      DEFAULT_HEALTH_UPDATE_DESCRIPTION;
 
     return config;
   });
@@ -48,18 +49,7 @@ const withSpikeHealthKit = (
       config.modResults['com.apple.developer.healthkit.access'] = [];
     }
 
-    if (isClinicalDataEnabled != false) {
-      config.modResults['com.apple.developer.healthkit.access'].push(
-        'health-records'
-      );
-
-      // Remove duplicates
-      config.modResults['com.apple.developer.healthkit.access'] = [
-        ...new Set(config.modResults['com.apple.developer.healthkit.access']),
-      ];
-    }
-
-    if (isBackgroundDeliveriesEnabled) {
+    if (isBackgroundDeliveryEnabled) {
       config.modResults[
         'com.apple.developer.healthkit.background-delivery'
       ] = true;
@@ -70,4 +60,254 @@ const withSpikeHealthKit = (
 
   return config;
 };
-module.exports = withSpikeHealthKit;
+
+/**
+ * Configures Android-specific settings for the Spike SDK
+ * @param {Object} config - Expo config object
+ * @param {Object} options - Configuration options
+ * @param {boolean} [options.isBackgroundDeliveryEnabled=true] - Whether to enable background health data deliveries
+ * @param {string[]} [options.healthConnectPermissions=[]] - Array of Health Connect Android permissions to add to the manifest
+ * @returns {Object} Modified config object
+ */
+const withSpikeAndroid = (config, { isBackgroundDeliveryEnabled = true, healthConnectPermissions = [] } = {}) => {
+  // Add Maven repository to allprojects repositories
+  config = withProjectBuildGradle(config, (config) => {
+    const mavenUrl = 'https://gitlab.com/api/v4/projects/43396247/packages/maven';
+    // Find the allprojects block
+    const allprojectsRegex = /allprojects\s*\{[\s\S]*?repositories\s*\{([\s\S]*?)\}/;
+    const match = config.modResults.contents.match(allprojectsRegex);
+    if (match) {
+      // Check if the maven repository is already in the repositories block
+      if (!match[1].includes(`url '${mavenUrl}'`)) {
+        // Add the maven repository to the repositories block
+        const updatedContents = config.modResults.contents.replace(
+          allprojectsRegex,
+          (allBlock) =>
+            allBlock.replace(
+              /repositories\s*\{/,
+              `repositories {\n        maven {\n            url '${mavenUrl}'\n        }`
+            )
+        );
+        config.modResults.contents = updatedContents;
+      }
+    } else {
+      // No allprojects block found, add it at the end of the file
+      if (!config.modResults.contents.includes(`url '${mavenUrl}'`)) {
+        const insertPosition = config.modResults.contents.lastIndexOf('}');
+        if (insertPosition !== -1) {
+          const beforeInsert = config.modResults.contents.substring(0, insertPosition);
+          const afterInsert = config.modResults.contents.substring(insertPosition);
+          config.modResults.contents = `${beforeInsert}\n\nallprojects {\n    repositories {\n        maven {\n            url '${mavenUrl}'\n        }\n    }\n}${afterInsert}`;
+        }
+      }
+    }
+    return config;
+  });
+
+  // Set minSdkVersion to 28 if it's less than 28 or not set
+  config = withProjectBuildGradle(config, (config) => {
+    // Find the buildscript.ext block and update minSdkVersion
+    const buildscriptExtRegex = /buildscript\s*\{\s*ext\s*\{([\s\S]*?)\}/;
+    const match = config.modResults.contents.match(buildscriptExtRegex);
+    
+    if (match) {
+      const extBlock = match[1];
+      const minSdkRegex = /minSdkVersion\s*=\s*(\d+)/;
+      const minSdkMatch = extBlock.match(minSdkRegex);
+      
+      if (minSdkMatch) {
+        const currentMinSdk = parseInt(minSdkMatch[1], 10);
+        if (currentMinSdk < 28) {
+          // Replace the existing minSdkVersion
+          config.modResults.contents = config.modResults.contents.replace(
+            minSdkRegex,
+            'minSdkVersion = 28'
+          );
+        }
+      } else {
+        // No minSdkVersion found, add it to the ext block
+        config.modResults.contents = config.modResults.contents.replace(
+          buildscriptExtRegex,
+          (fullMatch, extBlock) => {
+            // Find the closing brace of the ext block
+            const lines = extBlock.split('\n');
+            const lastLineIndex = lines.length - 1;
+            const lastLine = lines[lastLineIndex];
+            
+            // Add minSdkVersion before the closing brace
+            lines.splice(lastLineIndex, 0, '        minSdkVersion = 28');
+            
+            return `buildscript {\n    ext {\n${lines.join('\n')}\n    }`;
+          }
+        );
+      }
+    } else {
+      // No buildscript.ext block found, add it
+      const buildscriptRegex = /buildscript\s*\{/;
+      const buildscriptMatch = config.modResults.contents.match(buildscriptRegex);
+      
+      if (buildscriptMatch) {
+        // Insert ext block after the opening buildscript brace
+        config.modResults.contents = config.modResults.contents.replace(
+          buildscriptRegex,
+          'buildscript {\n    ext {\n        minSdkVersion = 28\n    }'
+        );
+      }
+    }
+    
+    return config;
+  });
+
+  // Add tools replacement attributes to the AndroidManifest.xml file
+  config = withCustomAndroidManifest(config, { isBackgroundDeliveryEnabled, healthConnectPermissions });
+
+  return config;
+};
+
+/**
+ * Configures Android manifest with Spike SDK specific settings
+ * @param {Object} config - Expo config object
+ * @param {Object} options - Configuration options
+ * @param {boolean} [options.isBackgroundDeliveryEnabled=true] - Whether to enable background health data deliveries
+ * @param {string[]} [options.healthConnectPermissions=[]] - Array of Health Connect Android permissions to add to the manifest
+ * @returns {Object} Modified config object
+ */
+function withCustomAndroidManifest(config, { isBackgroundDeliveryEnabled = true, healthConnectPermissions = [] } = {}) {
+  return withAndroidManifest(config, async (config) => {
+    const androidManifest = config.modResults;
+    const manifest = androidManifest.manifest;
+    
+    // Ensure xmlns:tools is present in the <manifest> tag
+    if (!manifest.$['xmlns:tools']) {
+      manifest.$['xmlns:tools'] = 'http://schemas.android.com/tools';
+    }
+
+    // Add background health data permission to healthConnectPermissions when background delivery is enabled
+    if (isBackgroundDeliveryEnabled) {
+      const backgroundPermission = 'android.permission.health.READ_HEALTH_DATA_IN_BACKGROUND';
+      if (!healthConnectPermissions.includes(backgroundPermission)) {
+        healthConnectPermissions = [backgroundPermission, ...healthConnectPermissions];
+      }
+    }
+
+    // Add health connect permissions if provided
+    if (healthConnectPermissions && healthConnectPermissions.length > 0) {
+      if (!manifest['uses-permission']) {
+        manifest['uses-permission'] = [];
+      }
+      for (const permission of healthConnectPermissions) {
+        if (!manifest['uses-permission'].some(p => p['$'] && p['$']['android:name'] === permission)) {
+          manifest['uses-permission'].push({
+            $: {
+              'android:name': permission
+            }
+          });
+        }
+      }
+    }
+
+    const application = manifest.application[0];
+
+    // Add tools:replace attribute for dataExtractionRules and fullBackupContent
+    application['$']['tools:replace'] = 'android:dataExtractionRules, android:fullBackupContent';
+
+    // Set dataExtractionRules and fullBackupContent as attributes within <application>
+    application['$']['android:dataExtractionRules'] = '@xml/secure_store_data_extraction_rules';
+    application['$']['android:fullBackupContent'] = '@xml/secure_store_backup_rules';
+
+    // Find the main activity and add the intent filter for permissions rationale
+    if (application.activity) {
+      for (const activity of application.activity) {
+        if (activity['$'] && activity['$']['android:name'] && 
+            activity['$']['android:name'].endsWith('.MainActivity')) {
+          
+          // Initialize intent-filter array if it doesn't exist
+          if (!activity['intent-filter']) {
+            activity['intent-filter'] = [];
+          }
+          
+          // Check if the permissions rationale intent filter already exists
+          const hasPermissionsRationale = activity['intent-filter'].some(filter => 
+            filter.action && filter.action.some(action => 
+              action['$']['android:name'] === 'androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE'
+            )
+          );
+          
+          if (!hasPermissionsRationale) {
+            activity['intent-filter'].push({
+              action: [{
+                $: {
+                  'android:name': 'androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE'
+                }
+              }]
+            });
+          }
+          break;
+        }
+      }
+    }
+
+    // Add activity-alias for ViewPermissionUsageActivity
+    if (!application['activity-alias']) {
+      application['activity-alias'] = [];
+    }
+    
+    // Check if the activity-alias already exists
+    const hasViewPermissionUsageActivity = application['activity-alias'].some(alias => 
+      alias['$'] && alias['$']['android:name'] === 'ViewPermissionUsageActivity'
+    );
+    
+    if (!hasViewPermissionUsageActivity) {
+      application['activity-alias'].push({
+        $: {
+          'android:name': 'ViewPermissionUsageActivity',
+          'android:exported': 'true',
+          'android:targetActivity': '.MainActivity',
+          'android:permission': 'android.permission.START_VIEW_PERMISSION_USAGE'
+        },
+        'intent-filter': [{
+          action: [{
+            $: {
+              'android:name': 'android.intent.action.VIEW_PERMISSION_USAGE'
+            }
+          }],
+          category: [{
+            $: {
+              'android:name': 'android.intent.category.HEALTH_PERMISSIONS'
+            }
+          }]
+        }]
+      });
+    }
+
+    return config;
+  });
+};
+
+/**
+ * Main plugin function that configures the Spike SDK for both iOS and Android
+ * @param {Object} config - Expo config object
+ * @param {Object} props - Configuration properties
+ * @param {Object} [props.ios] - iOS-specific configuration
+ * @param {string} [props.ios.healthSharePermission] - Custom description for health share permission (NSHealthShareUsageDescription)
+ * @param {string} [props.ios.healthUpdatePermission] - Custom description for health update permission (NSHealthUpdateUsageDescription)
+ * @param {boolean} [props.ios.isBackgroundDeliveryEnabled=true] - Whether to enable background health data deliveries (defaults to true)
+ * @param {Object} [props.android] - Android-specific configuration
+ * @param {boolean} [props.android.isBackgroundDeliveryEnabled=true] - Whether to enable background health data deliveries (defaults to true)
+ * @param {string[]} [props.android.healthConnectPermissions=[]] - Array of Health Connect Android permissions to add to the manifest
+ * @returns {Object} Modified config object
+ * 
+ */
+const withSpikeSdk = (config, props = {}) => {
+  const { ios = {}, android = {} } = props;
+  
+  // Apply iOS configuration
+  config = withSpikeHealthKit(config, ios);
+  
+  // Apply Android configuration
+  config = withSpikeAndroid(config, android);
+  
+  return config;
+};
+
+module.exports = withSpikeSdk;

package/lib/commonjs/index.js

@@ -57,6 +57,12 @@ Object.defineProperty(exports, "ProviderSource", {
     return _ProviderSource.ProviderSource;
   }
 });
+Object.defineProperty(exports, "SamsungHealthDataAvailabilityStatus", {
+  enumerable: true,
+  get: function () {
+    return _SamsungHealthDataAvailabilityStatus.SamsungHealthDataAvailabilityStatus;
+  }
+});
 Object.defineProperty(exports, "SleepConfig", {
   enumerable: true,
   get: function () {
@@ -182,6 +188,7 @@ var _StatisticsInterval = require("./v3/DataModels/StatisticsInterval");
 var _Unit = require("./v3/DataModels/Unit");
 var _StatisticsFilter = require("./v3/StatisticsFilter");
 var _HealthConnectAvailabilityStatus = require("./v3/DataModels/HealthConnectAvailabilityStatus");
+var _SamsungHealthDataAvailabilityStatus = require("./v3/DataModels/SamsungHealthDataAvailabilityStatus");
 var _ActivityAdditionalData = require("./v3/DataModels/ActivityAdditionalData");
 var _ActivityConfig = require("./v3/DataModels/ActivityConfig");
 var _SleepConfig = require("./v3/DataModels/SleepConfig");

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","_HealthConnectAvailabilityStatus","_ActivityAdditionalData","_ActivityConfig","_SleepConfig","_default","exports","default","createConnection","getBackgroundConnections","ensurePermissionsAreGranted","isPackageInstalled","isHealthDataAvailable","createConnectionAPIv3","createConnectionAPIv3Legacy"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAUA,IAAAE,gBAAA,GAAAF,OAAA;AAIA,IAAAG,eAAA,GAAAH,OAAA;AAqEA,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;AACA,IAAAgB,uBAAA,GAAAhB,OAAA;AACA,IAAAiB,eAAA,GAAAjB,OAAA;AAIA,IAAAkB,YAAA,GAAAlB,OAAA;AAA2F,IAAAmB,QAAA,GAAAC,OAAA,CAAAC,OAAA,GA9D5E;EACbC,gBAAgB,EAAhBA,uBAAgB;EAChBC,wBAAwB,EAAxBA,+BAAwB;EACxBC,2BAA2B,EAA3BA,kCAA2B;EAC3BC,kBAAkB,EAAlBA,yBAAkB;EAClBC,qBAAqB,EAArBA,4BAAqB;EACrB;EACAC,qBAAqB,EAArBA,4BAAqB;EACrBC,2BAA2B,EAA3BA;AACF,CAAC,EAmCD","ignoreList":[]}
+{"version":3,"names":["_SpikeDataTypes","require","_Spike","_SpikeConnection","_SpikeException","_SpikeRNConnectionAPIv","_ActivityTag","_ActivityType","_InputMethod","_MetricType","_Provider","_ProviderSource","_StatisticsType","_StatisticsInterval","_Unit","_StatisticsFilter","_HealthConnectAvailabilityStatus","_SamsungHealthDataAvailabilityStatus","_ActivityAdditionalData","_ActivityConfig","_SleepConfig","_default","exports","default","createConnection","getBackgroundConnections","ensurePermissionsAreGranted","isPackageInstalled","isHealthDataAvailable","createConnectionAPIv3","createConnectionAPIv3Legacy"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAUA,IAAAE,gBAAA,GAAAF,OAAA;AAIA,IAAAG,eAAA,GAAAH,OAAA;AAqEA,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;AACA,IAAAgB,oCAAA,GAAAhB,OAAA;AACA,IAAAiB,uBAAA,GAAAjB,OAAA;AACA,IAAAkB,eAAA,GAAAlB,OAAA;AAIA,IAAAmB,YAAA,GAAAnB,OAAA;AAA2F,IAAAoB,QAAA,GAAAC,OAAA,CAAAC,OAAA,GA/D5E;EACbC,gBAAgB,EAAhBA,uBAAgB;EAChBC,wBAAwB,EAAxBA,+BAAwB;EACxBC,2BAA2B,EAA3BA,kCAA2B;EAC3BC,kBAAkB,EAAlBA,yBAAkB;EAClBC,qBAAqB,EAArBA,4BAAqB;EACrB;EACAC,qBAAqB,EAArBA,4BAAqB;EACrBC,2BAA2B,EAA3BA;AACF,CAAC,EAmCD","ignoreList":[]}

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

@@ -54,9 +54,9 @@ let MetricType = exports.MetricType = /*#__PURE__*/function (MetricType) {
   MetricType["vo2Max"] = "vo2max";
   MetricType["bodyTemperature"] = "body_temperature";
   MetricType["skinTemperature"] = "skin_temperature";
-  MetricType["sleepBreathingRate"] = "sleep_breathing_rate";
-  MetricType["sleepBreathingRateMin"] = "sleep_breathing_rate_min";
-  MetricType["sleepBreathingRateMax"] = "sleep_breathing_rate_max";
+  MetricType["breathingRate"] = "breathing_rate";
+  MetricType["breathingRateMin"] = "breathing_rate_min";
+  MetricType["breathingRateMax"] = "breathing_rate_max";
   MetricType["bodyFat"] = "body_fat";
   MetricType["bodyFatMax"] = "body_fat_max";
   MetricType["bodyFatMin"] = "body_fat_min";

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

@@ -18,6 +18,7 @@ let Provider = exports.Provider = /*#__PURE__*/function (Provider) {
   Provider["apple"] = "apple";
   Provider["healthConnect"] = "health_connect";
   Provider["ultrahuman"] = "ultrahuman";
+  Provider["samsungHealthData"] = "samsung_health_data";
   Provider["unknown"] = "_unknown";
   return Provider;
 }({});

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

@@ -1 +1 @@
-{"version":3,"names":["Provider","exports"],"sourceRoot":"../../../../src","sources":["v3/DataModels/Provider.ts"],"mappings":";;;;;;AACA;AACA;AAAA,IACYA,QAAQ,GAAAC,OAAA,CAAAD,QAAA,0BAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAAA,OAARA,QAAQ;AAAA","ignoreList":[]}
+{"version":3,"names":["Provider","exports"],"sourceRoot":"../../../../src","sources":["v3/DataModels/Provider.ts"],"mappings":";;;;;;AACA;AACA;AAAA,IACYA,QAAQ,GAAAC,OAAA,CAAAD,QAAA,0BAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAAA,OAARA,QAAQ;AAAA","ignoreList":[]}

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

@@ -45,6 +45,7 @@ let ProviderSource = exports.ProviderSource = /*#__PURE__*/function (ProviderSou
   ProviderSource["withingsMeasureGetActivity"] = "withings_measure_get_activity";
   ProviderSource["withingsMeasureGetMeas"] = "withings_measure_get_meas";
   ProviderSource["wahooWorkoutSummary"] = "wahoo_workout_summary";
+  ProviderSource["samsungHealthDataAggregation"] = "samsung_health_data_aggregation";
   ProviderSource["unknown"] = "_unknown";
   return ProviderSource;
 }({});

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

@@ -1 +1 @@
-{"version":3,"names":["ProviderSource","exports"],"sourceRoot":"../../../../src","sources":["v3/DataModels/ProviderSource.ts"],"mappings":";;;;;;AACA;AACA;AAAA,IACYA,cAAc,GAAAC,OAAA,CAAAD,cAAA,0BAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA","ignoreList":[]}
+{"version":3,"names":["ProviderSource","exports"],"sourceRoot":"../../../../src","sources":["v3/DataModels/ProviderSource.ts"],"mappings":";;;;;;AACA;AACA;AAAA,IACYA,cAAc,GAAAC,OAAA,CAAAD,cAAA,0BAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA","ignoreList":[]}

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

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=SamsungHealthDataAvailability.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../../src","sources":["v3/DataModels/SamsungHealthDataAvailability.ts"],"mappings":"","ignoreList":[]}