react-native-spike-sdk 4.4.13 → 4.5.23-beta.1

package/android/build.gradle

@@ -76,10 +76,12 @@ 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.4.12'
+  implementation 'com.spikeapi.sdk:spike-sdk:4.5.22-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'
+  implementation 'com.squareup.moshi:moshi:1.15.0'
+  implementation 'com.squareup.moshi:moshi-kotlin:1.15.0'
 }
 
 if (isNewArchitectureEnabled()) {

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

@@ -17,6 +17,7 @@ import com.spikeapi.healthconnect.HealthConnectAvailability
 import com.spikeapi.apiv3.SpikeConnectionAPIv3
 import com.spikeapi.apiv3.datamodels.MetricType
 import com.spikeapi.apiv3.datamodels.ActivityConfig
+import com.spikeapi.apiv3.datamodels.RecordConfig
 import com.spikeapi.apiv3.datamodels.SleepConfig
 import com.spikeapi.apiv3.datamodels.StatisticsType
 import com.spikeapi.apiv3.datamodels.NutritionRecord
@@ -748,6 +749,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         from: String, // Instant
         to: String, // Instant
         filter: String?, // StatisticsFilter?
+        configJson: String?, // RecordConfig?
         promise: Promise
     ) {
         executeV3MethodWithConnection("getRecords", connectionUUID, promise) { connection ->
@@ -757,12 +759,14 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
             val dateFrom = convertIsoStringToInstant(from)
             val dateTo = convertIsoStringToInstant(to)
             val statsFilter = StatisticsFilter.fromValue(filter)
+            val recordConfig = makeRecordConfig(configJson)
 
             val result = connection.getRecords(
                 types = statTypes,
                 from = dateFrom,
                 to = dateTo,
-                filter = statsFilter
+                filter = statsFilter,
+                config = recordConfig
             )
 
             promise.resolve(SpikeConnectionAPIv3.convertToJson(result))
@@ -1123,6 +1127,45 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun backfill(
+        connectionUUID: String,
+        days: String?,
+        statisticTypes: ReadableArray,
+        metricTypes: ReadableArray,
+        activityConfigs: ReadableArray,
+        sleepConfigs: ReadableArray,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("backfill", connectionUUID, promise) { connection ->
+            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()
+
+            connection.backfill(
+                days = days?.toIntOrNull(),
+                statisticsTypes = statTypes,
+                metricTypes = mTypes,
+                activityConfigs = aConfigs,
+                sleepConfigs = sConfigs
+            )
+
+            promise.resolve(true)
+        }
+    }
+
     @ReactMethod
     fun disableBackgroundDelivery(
         connectionUUID: String, 
@@ -1393,7 +1436,50 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun requestSamsungPermissionsAndBackfill(
+        connectionUUID: String,
+        statisticTypes: ReadableArray,
+        metricTypes: ReadableArray,
+        activityConfigs: ReadableArray,
+        sleepConfigs: ReadableArray,
+        days: String?,
+        promise: Promise
+    ) {
+        executeV3MethodWithConnection("requestSamsungPermissionsAndBackfill", connectionUUID, promise) { connection ->
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                throw SpikeExceptions.SpikeException("Activity is required to request Samsung Health Data permissions and backfill")
+            }
+
+            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()
 
+            connection.requestSamsungPermissionsAndBackfill(
+                activity = activity,
+                statisticsTypes = statTypes,
+                metricTypes = mTypes,
+                activityConfigs = aConfigs,
+                sleepConfigs = sConfigs,
+                backfillDays = days?.toIntOrNull()
+            )
+
+            promise.resolve(true)
+        }
+    }
 
     /// --- Nutrition AI ---
 
@@ -1594,6 +1680,15 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
 
 }
 
+private fun makeRecordConfig(json: String?): RecordConfig? {
+    if (json == null) return null
+    val moshi = com.squareup.moshi.Moshi.Builder()
+        .addLast(com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory())
+        .build()
+    val adapter = moshi.adapter(RecordConfig::class.java)
+    return adapter.fromJson(json)
+}
+
 private fun convertIsoStringToInstant(isoString: String): Instant {
     return Instant.parse(isoString)
 }

package/ios/SpikeSdk.m

@@ -122,6 +122,15 @@ RCT_EXTERN_METHOD(requestPermissionsFromHealthKit: (NSString)connectionUUID
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(requestPermissionsFromHealthKitAndBackfill: (NSString)connectionUUID
+                  withStatistics: (NSArray<NSString>)statistics
+                  metrics: (NSArray<NSString>)metrics
+                  activityConfigs: (NSArray<NSString>)activityConfigs
+                  sleepConfigs: (NSArray<NSString>)sleepConfigs
+                  days: (NSString)days
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(getUserInfo: (NSString)connectionUUID
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
@@ -151,6 +160,7 @@ RCT_EXTERN_METHOD(getRecords: (NSString)connectionUUID
                   from: (NSString)from
                   to: (NSString)to
                   filter: (NSString)filter
+                  config: (NSString)config
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
 
@@ -180,6 +190,15 @@ RCT_EXTERN_METHOD(enableBackgroundDeliveryV3: (NSString)connectionUUID
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(backfill: (NSString)connectionUUID
+                  days: (NSString)days
+                  withStatistics: (NSArray<NSString>)statistics
+                  metrics: (NSArray<NSString>)metrics
+                  activityConfigs: (NSArray<NSString>)activityConfigs
+                  sleepConfigs: (NSArray<NSString>)sleepConfigs
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(disableBackgroundDelivery: (NSString)connectionUUID
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)

package/ios/SpikeSdk.swift

@@ -611,6 +611,59 @@ class SpikeSdk: RCTEventEmitter {
         }
     }
     
+    @objc(requestPermissionsFromHealthKitAndBackfill:
+        withStatistics:
+        metrics:
+        activityConfigs:
+        sleepConfigs:
+        days:
+        withResolver:
+        withRejecter:)
+    func requestPermissionsFromHealthKitAndBackfill(
+        connectionUUID: String,
+        forStatistics statistics: [String],
+        metrics: [String],
+        activityConfigs: [String],
+        sleepConfigs: [String],
+        days: String?,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                let stats = statistics.compactMap {
+                    StatisticsType(rawValue: $0)
+                }
+                let metricsObjects = metrics.compactMap {
+                    MetricType(rawValue: $0)
+                }
+                let activityConfigsObjects = activityConfigs.compactMap {
+                    try? makeActivityConfig(fromString: $0)
+                }
+                let sleepConfigsObjects = sleepConfigs.compactMap {
+                    try? makeSleepConfig(fromString: $0)
+                }
+                
+                let daysValue: Int? = days != nil ? Int(days!) : nil
+                try await connection.requestPermissionsFromHealthKitAndBackfill(
+                    forStatistics: stats,
+                    forMetrics: metricsObjects,
+                    forActivities: activityConfigsObjects,
+                    forSleep: sleepConfigsObjects,
+                    backfillDays: daysValue
+                )
+                
+                resolve(Void())
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
     @objc(getUserInfo:
         withResolver:
         withRejecter:)
@@ -728,6 +781,7 @@ class SpikeSdk: RCTEventEmitter {
             from:
             to:
             filter:
+            config:
             withResolver:
             withRejecter:)
     func getRecords(
@@ -736,6 +790,7 @@ class SpikeSdk: RCTEventEmitter {
         from: String, // Date
         to: String, // Date
         filter: String?, // StatisticsFilter?
+        config: String?, // RecordConfig?
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) { // -> [Record]
@@ -747,12 +802,14 @@ class SpikeSdk: RCTEventEmitter {
                 let dateFrom = try makeDate(fromString: from)
                 let dateTo = try makeDate(fromString: to)
                 let statsFilter = try makeStatisticsFilter(fromString: filter)
+                let recordConfig = try makeRecordConfig(fromString: config)
                 
                 let result = try await connection.getRecords(
                     ofTypes: types.compactMap{ MetricType(rawValue: $0) },
                     from: dateFrom,
                     to: dateTo,
-                    filter: statsFilter
+                    filter: statsFilter,
+                    configured: recordConfig
                 )
                 
                 let encoder = SpikeSDK.JSONEncoder.spikeDefaultJsonEncoder
@@ -904,6 +961,59 @@ class SpikeSdk: RCTEventEmitter {
         }
     }
     
+    @objc(backfill:
+            days:
+            withStatistics:
+            metrics:
+            activityConfigs:
+            sleepConfigs:
+            withResolver:
+            withRejecter:)
+    func backfill(
+        connectionUUID: String,
+        days: String?,
+        withStatistics statistics: [String],
+        metrics: [String],
+        activityConfigs: [String],
+        sleepConfigs: [String],
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task {
+            do {
+                guard let connection = getConnectionV3(withUUID: connectionUUID) else {
+                    spikeReject(with: SpikeConnectionNotFoundException(), reject: reject)
+                    return
+                }
+                let stats = statistics.compactMap {
+                    StatisticsType(rawValue: $0)
+                }
+                let metricsObjects = metrics.compactMap {
+                    MetricType(rawValue: $0)
+                }
+                let activityConfigsObjects = activityConfigs.compactMap {
+                    try? makeActivityConfig(fromString: $0)
+                }
+                let sleepConfigsObjects = sleepConfigs.compactMap {
+                    try? makeSleepConfig(fromString: $0)
+                }
+                
+                let daysValue: Int? = days != nil ? Int(days!) : nil
+                try await connection.backfill(
+                    days: daysValue,
+                    forStatistics: stats,
+                    forMetrics: metricsObjects,
+                    forActivities: activityConfigsObjects,
+                    forSleep: sleepConfigsObjects
+                )
+                
+                resolve(true)
+            } catch let error {
+                spikeReject(with: error, reject: reject)
+            }
+        }
+    }
+    
     @objc(disableBackgroundDelivery:
             withResolver:
             withRejecter:)
@@ -984,6 +1094,18 @@ class SpikeSdk: RCTEventEmitter {
         return date
     }
     
+    private func makeRecordConfig(fromString string: String?) throws -> RecordConfig? {
+        guard let string else {
+            return nil
+        }
+        guard let data = string.data(using: .utf8) else {
+            throw SpikeDataDecodingException()
+        }
+        let decoder = SpikeSDK.JSONDecoder.spikeDefaultJsonDecoder
+        let config = try decoder.decode(RecordConfig.self, from: data)
+        return config
+    }
+    
     private func makeActivityConfig(fromString string: String?) throws -> ActivityConfig? {
         guard let string else {
             return ActivityConfig()

package/lib/commonjs/index.js

@@ -111,6 +111,12 @@ Object.defineProperty(exports, "ProviderSource", {
     return _ProviderSource.ProviderSource;
   }
 });
+Object.defineProperty(exports, "RecordConfig", {
+  enumerable: true,
+  get: function () {
+    return _RecordConfig.RecordConfig;
+  }
+});
 Object.defineProperty(exports, "SamsungHealthDataAvailabilityStatus", {
   enumerable: true,
   get: function () {
@@ -248,6 +254,7 @@ var _SamsungHealthDataAvailabilityStatus = require("./v3/DataModels/SamsungHealt
 var _ActivityAdditionalData = require("./v3/DataModels/ActivityAdditionalData");
 var _ActivityConfig = require("./v3/DataModels/ActivityConfig");
 var _SleepConfig = require("./v3/DataModels/SleepConfig");
+var _RecordConfig = require("./v3/RecordConfig");
 var _LogLevel = require("./v3/DataModels/LogLevel");
 var _NutritionRecordStatus = require("./v3/DataModels/NutritionRecordStatus");
 var _NutritionRecordAnalysisMode = require("./v3/DataModels/NutritionRecordAnalysisMode");

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_SpikeDataTypes","require","_Spike","_SpikeConnection","_SpikeException","_SpikeRNConnectionAPIv","_ActivityTag","_ActivityType","_ActivityCategory","_InputMethod","_MetricType","_Provider","_ProviderSource","_StatisticsType","_StatisticsInterval","_Unit","_StatisticsFilter","_HealthConnectAvailabilityStatus","_HealthConnectFeature","_SamsungHealthDataAvailabilityStatus","_ActivityAdditionalData","_ActivityConfig","_SleepConfig","_LogLevel","_NutritionRecordStatus","_NutritionRecordAnalysisMode","_NutritionalField","_NutritionalUnit","_NutritionRecordUtils","_NutritionRecordIngredientUtils","_default","exports","default","createConnection","getBackgroundConnections","ensurePermissionsAreGranted","isPackageInstalled","isHealthDataAvailable","createConnectionAPIv3","createConnectionAPIv3Legacy","setLogCallback"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAYA,IAAAE,gBAAA,GAAAF,OAAA;AAIA,IAAAG,eAAA,GAAAH,OAAA;AAuEA,IAAAI,sBAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA;AACA,IAAAM,aAAA,GAAAN,OAAA;AACA,IAAAO,iBAAA,GAAAP,OAAA;AACA,IAAAQ,YAAA,GAAAR,OAAA;AACA,IAAAS,WAAA,GAAAT,OAAA;AACA,IAAAU,SAAA,GAAAV,OAAA;AACA,IAAAW,eAAA,GAAAX,OAAA;AACA,IAAAY,eAAA,GAAAZ,OAAA;AACA,IAAAa,mBAAA,GAAAb,OAAA;AACA,IAAAc,KAAA,GAAAd,OAAA;AACA,IAAAe,iBAAA,GAAAf,OAAA;AACA,IAAAgB,gCAAA,GAAAhB,OAAA;AACA,IAAAiB,qBAAA,GAAAjB,OAAA;AACA,IAAAkB,oCAAA,GAAAlB,OAAA;AACA,IAAAmB,uBAAA,GAAAnB,OAAA;AACA,IAAAoB,eAAA,GAAApB,OAAA;AAIA,IAAAqB,YAAA,GAAArB,OAAA;AAQA,IAAAsB,SAAA,GAAAtB,OAAA;AAIA,IAAAuB,sBAAA,GAAAvB,OAAA;AACA,IAAAwB,4BAAA,GAAAxB,OAAA;AAEA,IAAAyB,iBAAA,GAAAzB,OAAA;AACA,IAAA0B,gBAAA,GAAA1B,OAAA;AAGA,IAAA2B,qBAAA,GAAA3B,OAAA;AAIA,IAAA4B,+BAAA,GAAA5B,OAAA;AAGmD,IAAA6B,QAAA,GAAAC,OAAA,CAAAC,OAAA,GA7FpC;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,kCAA2B;EAC3BC,cAAc,EAAdA;AACF,CAAC,EAoCD","ignoreList":[]}
+{"version":3,"names":["_SpikeDataTypes","require","_Spike","_SpikeConnection","_SpikeException","_SpikeRNConnectionAPIv","_ActivityTag","_ActivityType","_ActivityCategory","_InputMethod","_MetricType","_Provider","_ProviderSource","_StatisticsType","_StatisticsInterval","_Unit","_StatisticsFilter","_HealthConnectAvailabilityStatus","_HealthConnectFeature","_SamsungHealthDataAvailabilityStatus","_ActivityAdditionalData","_ActivityConfig","_SleepConfig","_RecordConfig","_LogLevel","_NutritionRecordStatus","_NutritionRecordAnalysisMode","_NutritionalField","_NutritionalUnit","_NutritionRecordUtils","_NutritionRecordIngredientUtils","_default","exports","default","createConnection","getBackgroundConnections","ensurePermissionsAreGranted","isPackageInstalled","isHealthDataAvailable","createConnectionAPIv3","createConnectionAPIv3Legacy","setLogCallback"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAYA,IAAAE,gBAAA,GAAAF,OAAA;AAIA,IAAAG,eAAA,GAAAH,OAAA;AAuEA,IAAAI,sBAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA;AACA,IAAAM,aAAA,GAAAN,OAAA;AACA,IAAAO,iBAAA,GAAAP,OAAA;AACA,IAAAQ,YAAA,GAAAR,OAAA;AACA,IAAAS,WAAA,GAAAT,OAAA;AACA,IAAAU,SAAA,GAAAV,OAAA;AACA,IAAAW,eAAA,GAAAX,OAAA;AACA,IAAAY,eAAA,GAAAZ,OAAA;AACA,IAAAa,mBAAA,GAAAb,OAAA;AACA,IAAAc,KAAA,GAAAd,OAAA;AACA,IAAAe,iBAAA,GAAAf,OAAA;AACA,IAAAgB,gCAAA,GAAAhB,OAAA;AACA,IAAAiB,qBAAA,GAAAjB,OAAA;AACA,IAAAkB,oCAAA,GAAAlB,OAAA;AACA,IAAAmB,uBAAA,GAAAnB,OAAA;AACA,IAAAoB,eAAA,GAAApB,OAAA;AAIA,IAAAqB,YAAA,GAAArB,OAAA;AACA,IAAAsB,aAAA,GAAAtB,OAAA;AAQA,IAAAuB,SAAA,GAAAvB,OAAA;AAIA,IAAAwB,sBAAA,GAAAxB,OAAA;AACA,IAAAyB,4BAAA,GAAAzB,OAAA;AAEA,IAAA0B,iBAAA,GAAA1B,OAAA;AACA,IAAA2B,gBAAA,GAAA3B,OAAA;AAGA,IAAA4B,qBAAA,GAAA5B,OAAA;AAIA,IAAA6B,+BAAA,GAAA7B,OAAA;AAGmD,IAAA8B,QAAA,GAAAC,OAAA,CAAAC,OAAA,GA9FpC;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,kCAA2B;EAC3BC,cAAc,EAAdA;AACF,CAAC,EAoCD","ignoreList":[]}

package/lib/commonjs/v3/RecordConfig.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RecordConfig = void 0;
+class RecordConfig {
+  includeSamples = false;
+  constructor({
+    includeSamples = false
+  }) {
+    this.includeSamples = includeSamples;
+  }
+}
+exports.RecordConfig = RecordConfig;
+//# sourceMappingURL=RecordConfig.js.map

package/lib/commonjs/v3/RecordConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RecordConfig","includeSamples","constructor","exports"],"sourceRoot":"../../../src","sources":["v3/RecordConfig.ts"],"mappings":";;;;;;AAIO,MAAMA,YAAY,CAAC;EACtBC,cAAc,GAAY,KAAK;EAE/BC,WAAWA,CAAC;IACRD,cAAc,GAAG;EACc,CAAC,EAAE;IAClC,IAAI,CAACA,cAAc,GAAGA,cAAc;EACxC;AACJ;AAACE,OAAA,CAAAH,YAAA,GAAAA,YAAA","ignoreList":[]}

package/lib/commonjs/v3/SpikeRNConnectionAPIv3.js

@@ -81,12 +81,12 @@ class SpikeRNConnectionAPIv3 {
     ofTypes,
     from,
     to,
-    filter = null
+    filter = null,
+    config = null
   }) {
     if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
     const stringTypes = ofTypes.map(item => item);
-    // console.log("Record types requested",  stringTypes)
-    const result = await _SpikeSdk.SpikeSdk.getRecords(this.connectionUUID, stringTypes, from.toISOString(), to.toISOString(), !!filter ? JSON.stringify(filter) : null);
+    const result = await _SpikeSdk.SpikeSdk.getRecords(this.connectionUUID, stringTypes, from.toISOString(), to.toISOString(), !!filter ? JSON.stringify(filter) : null, config ? JSON.stringify((0, _Conversion.camelToSnake)(config)) : null);
     const jsonResult = JSON.parse(result);
     const finalResult = (0, _Conversion.snakeToCamel)(jsonResult);
     return finalResult;
@@ -219,6 +219,29 @@ class SpikeRNConnectionAPIv3 {
     }
   }
 
+  /**
+   * Triggers a backfill of health data for the specified number of days.
+   *
+   * This method pushes historical health data to the Spike backend. It requires that
+   * health permissions have already been granted (via `requestHealthPermissions` on iOS
+   * or Health Connect / Samsung Health Data integration on Android).
+   *
+   * The number of days to backfill configured in the Spike dashboard will be used if
+   * `days` is not provided.
+   *
+   * @category Backfill
+   */
+  async backfill({
+    days = undefined,
+    statisticTypes = [],
+    metricTypes = [],
+    activityConfigs = [],
+    sleepConfigs = []
+  }) {
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    await _SpikeSdk.SpikeSdk.backfill(this.connectionUUID, days !== undefined ? String(days) : null, statisticTypes, metricTypes, activityConfigs.map(object => JSON.stringify(object)), sleepConfigs.map(object => JSON.stringify(object)));
+  }
+
   /**
    * Disables background checks for new data.
    * 
@@ -273,6 +296,27 @@ class SpikeRNConnectionAPIv3 {
     return await _SpikeSdk.SpikeSdk.isHealthKitIntegrationEnabled(this.connectionUUID);
   }
 
+  /**
+   * Requests HealthKit read permissions for the given categories, then starts a backfill.
+   * Data for today and yesterday is pushed before this method resolves; older days continue in the background.
+   *
+   * For manual control over backfill, use {@link requestHealthPermissions} and {@link backfill} instead.
+   *
+   * @category iOS HealthKit
+   * @category Backfill
+   */
+  async requestPermissionsFromHealthKitAndBackfill({
+    days = undefined,
+    statisticTypes = [],
+    metricTypes = [],
+    activityConfigs = [],
+    sleepConfigs = []
+  }) {
+    if (_reactNative.Platform.OS !== 'ios') return;
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    await _SpikeSdk.SpikeSdk.requestPermissionsFromHealthKitAndBackfill(this.connectionUUID, statisticTypes, metricTypes, activityConfigs.map(object => JSON.stringify(object)), sleepConfigs.map(object => JSON.stringify(object)), days !== undefined ? String(days) : null);
+  }
+
   // ------------------------- Android specific Health Connect permissions -------------------------
 
   /**
@@ -418,6 +462,51 @@ class SpikeRNConnectionAPIv3 {
     return await _SpikeSdk.SpikeSdk.isHealthConnectFeatureAvailable(this.connectionUUID, feature);
   }
 
+  /**
+   * Enables Health Connect integration, requests permissions for the given categories, then starts a backfill.
+   * Data for today and yesterday is pushed before this method resolves; older days continue in the background.
+   *
+   * This mirrors the native {@link requestSamsungPermissionsAndBackfill} flow: enable integration,
+   * request permissions, then run backfill (implemented by composing existing Health Connect APIs).
+   *
+   * For manual control, use {@link enableHealthConnectIntegration}, {@link getHealthConnectPermissions},
+   * {@link requestPermissionsFromHealthConnect}, and {@link backfill} instead.
+   *
+   * @category Android Health Connect
+   * @category Backfill
+   */
+  async requestHealthConnectPermissionsAndBackfill({
+    days = undefined,
+    statisticTypes = [],
+    metricTypes = [],
+    activityConfigs = [],
+    sleepConfigs = [],
+    includeEnhancedPermissions = false,
+    includeBackgroundDelivery = false
+  }) {
+    if (_reactNative.Platform.OS !== 'android') return;
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    await this.enableHealthConnectIntegration();
+    const permissions = await this.getHealthConnectPermissions({
+      statisticTypes,
+      metricTypes,
+      activityConfigs,
+      sleepConfigs,
+      includeEnhancedPermissions,
+      includeBackgroundDelivery
+    });
+    await this.requestPermissionsFromHealthConnect({
+      permissions
+    });
+    await this.backfill({
+      days,
+      statisticTypes,
+      metricTypes,
+      activityConfigs,
+      sleepConfigs
+    });
+  }
+
   // ------------------------- Samsung Health Data permissions -------------------------
 
   /**
@@ -531,6 +620,27 @@ class SpikeRNConnectionAPIv3 {
     return await _SpikeSdk.SpikeSdk.requestPermissionsFromSamsungHealthData(this.connectionUUID, statisticTypes, metricTypes, activityConfigs.map(object => JSON.stringify(object)), sleepConfigs.map(object => JSON.stringify(object)));
   }
 
+  /**
+   * Enables Samsung Health Data integration, requests permissions for the given categories, then starts a backfill.
+   * Data for today and yesterday is pushed before this method resolves; older days continue in the background.
+   *
+   * For manual control, use {@link enableSamsungHealthDataIntegration}, {@link requestPermissionsFromSamsungHealthData}, and {@link backfill} instead.
+   *
+   * @category Samsung Health Data
+   * @category Backfill
+   */
+  async requestSamsungPermissionsAndBackfill({
+    days = undefined,
+    statisticTypes = [],
+    metricTypes = [],
+    activityConfigs = [],
+    sleepConfigs = []
+  }) {
+    if (_reactNative.Platform.OS !== 'android') return;
+    if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
+    await _SpikeSdk.SpikeSdk.requestSamsungPermissionsAndBackfill(this.connectionUUID, statisticTypes, metricTypes, activityConfigs.map(object => JSON.stringify(object)), sleepConfigs.map(object => JSON.stringify(object)), days !== undefined ? String(days) : null);
+  }
+
   // ------------------------- Nutrition AI -------------------------
 
   /**