@kingstinct/react-native-healthkit 9.0.7 → 9.0.8

package/ios/WorkoutsModule.swift

@@ -6,55 +6,6 @@ import NitroModules
 import WorkoutKit
 #endif
 
-/*func tryParseWeatherCondition(_ weatherCondition: Int?) -> WeatherCondition? {
-    if let weatherCondition = weatherCondition {
-        return WeatherCondition.init(rawValue: Int32(weatherCondition))
-    }
-    return nil
-}
-
-func deserializeWorkoutMetadata(_ metadata: WorkoutMetadata?) -> [String: Any]? {
-    if let metadata = metadata {
-        var dict = metadata.allMetadata != nil
-        ? anyMapToDictionary(metadata.allMetadata!)
-        : Dictionary<String, Any>()
-        // todo (important): hmm, not sure about the typed props here
-        // dict[""]
-        return dict
-    }
-    return nil
-}
-
-func serializeWorkoutMetadata(_ metadata: [String: Any]?) -> WorkoutMetadata? {
-    if let metadata = metadata {
-        return WorkoutMetadata(
-            // todo: figure out conversions here
-            HKWeatherCondition: tryParseWeatherCondition(metadata["HKWeatherCondition"] as? Int),
-            HKWeatherHumidity: serializeUnknownQuantityTyped(quantity: metadata["HKWeatherHumidity"] as? HKQuantity),
-            HKWeatherTemperature: serializeUnknownQuantityTyped(quantity: metadata["HKWeatherTemperature"] as? HKQuantity),
-            HKAverageMETs: serializeUnknownQuantityTyped(quantity: metadata["HKAverageMETs"] as? HKQuantity),
-            HKElevationAscended: serializeUnknownQuantityTyped(quantity: metadata["HKElevationAscended"] as? HKQuantity),
-            HKIndoorWorkout: metadata["HKIndoorWorkout"] as? Bool,
-            HKExternalUUID: metadata["HKExternalUUID"] as? String,
-            HKTimeZone: metadata["HKTimeZone"] as? String,
-            HKWasUserEntered: metadata["HKWasUserEntered"] as? Bool,
-            HKDeviceSerialNumber: metadata["HKDeviceSerialNumber"] as? String,
-            HKUDIDeviceIdentifier: metadata["HKUDIDeviceIdentifier"] as? String,
-            HKUDIProductionIdentifier: metadata["HKUDIProductionIdentifier"] as? String,
-            HKDigitalSignature: metadata["HKDigitalSignature"] as? String,
-            HKDeviceName: metadata["HKDeviceName"] as? String,
-            HKDeviceManufacturerName: metadata["HKDeviceManufacturerName"] as? String,
-            HKSyncIdentifier: metadata["HKSyncIdentifier"] as? String,
-            HKSyncVersion: metadata["HKSyncVersion"] as? Double,
-            HKWasTakenInLab: metadata["HKWasTakenInLab"] as? Bool,
-            HKReferenceRangeLowerLimit: metadata["HKReferenceRangeLowerLimit"] as? Double,
-            HKReferenceRangeUpperLimit: metadata["HKReferenceRangeUpperLimit"] as? Double,
-            allMetadata: serializeAllMetadata(metadata)
-        )
-    }
-    return nil
-}*/
-
 func mapLocations(from locations: [LocationForSaving]) -> [CLLocation] {
     return locations.compactMap { location in
         let latitude = location.latitude
@@ -65,7 +16,7 @@ func mapLocations(from locations: [LocationForSaving]) -> [CLLocation] {
         let course = location.course
         let speed = location.speed
         let timestamp = location.date
-        
+
         let clLocation = CLLocation(
             coordinate: CLLocationCoordinate2D(
                 latitude: latitude,
@@ -76,24 +27,40 @@ func mapLocations(from locations: [LocationForSaving]) -> [CLLocation] {
             verticalAccuracy: verticalAccuracy,
             course: course,
             speed: speed,
-            timestamp: timestamp,
+            timestamp: timestamp
         )
-        
+
         return clLocation
     }
 }
 
-class WorkoutsModule : HybridWorkoutsModuleSpec {
+class WorkoutsModule: HybridWorkoutsModuleSpec {
+    func startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration) throws -> Promise<Bool> {
+        let configuration = parseWorkoutConfiguration(workoutConfiguration)
+
+        return Promise.async {
+            try await withCheckedThrowingContinuation { continuation in
+                store.startWatchApp(with: configuration) { success, error in
+                  if let error {
+                      continuation.resume(throwing: RuntimeError.error(withMessage: error.localizedDescription))
+                  }
+
+                  continuation.resume(returning: success)
+                }
+            }
+        }
+    }
+
     func queryWorkoutSamples(options: WorkoutQueryOptions) throws -> Promise<[HybridWorkoutProxySpec]> {
         let predicate = try createPredicateForWorkout(filter: options.filter)
-        
+
         let limit = getQueryLimit(options.limit)
-        
+
         return Promise.async {
             let energyUnit = try await getUnitToUse(unitOverride: options.energyUnit, quantityType: HKQuantityType(.activeEnergyBurned))
-            
+
             let distanceUnit = try await getUnitToUse(unitOverride: options.distanceUnit, quantityType: HKQuantityType(.distanceWalkingRunning))
-            
+
             return try await withCheckedThrowingContinuation { continuation in
                 let q = HKSampleQuery(
                     sampleType: .workoutType(),
@@ -104,11 +71,11 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                     if let error = error {
                         return continuation.resume(throwing: error)
                     }
-                    
+
                     guard let samples = samples else {
                         return continuation.resume(throwing: RuntimeError.error(withMessage: "Empty response"))
                     }
-                    
+
                     let workoutProxies = samples.compactMap { s in
                         if let workout = s as? HKWorkout {
                             return WorkoutProxy.init(
@@ -119,15 +86,15 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                         }
                         return nil
                     }
-                    
+
                     return continuation.resume(returning: workoutProxies)
                 }
-                
+
                 store.execute(q)
             }
         }
     }
-    
+
     func saveWorkoutSample(
         workoutActivityType: WorkoutActivityType,
         quantities: [QuantitySampleForSaving],
@@ -136,18 +103,18 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
         totals: WorkoutTotals,
         metadata: AnyMapHolder
     ) throws -> Promise<String> {
-        
+
         let type = try initializeWorkoutActivityType(UInt(workoutActivityType.rawValue))
-        
+
         // if start and end both exist,  ensure that start date is before end date
         if let startDate = startDate as Date?, let endDate = endDate as Date? {
             if startDate > endDate {
                 throw RuntimeError.error(withMessage: "endDate must not be less than startDate")
             }
         }
-        
+
         let metadataDeserialized = anyMapToDictionary(metadata)
-        
+
         var totalEnergyBurned: HKQuantity?
         var totalDistance: HKQuantity?
         var totalSwimmingStrokeCount: HKQuantity?
@@ -161,23 +128,23 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
             let quantityEnd = quantity.endDate
             let unit = HKUnit.init(from: unitStr)
             let quantity = HKQuantity.init(unit: unit, doubleValue: quantityVal)
-            
+
             if quantity.is(compatibleWith: HKUnit.kilocalorie()) {
                 totalEnergyBurned = quantity
             }
-            
+
             if quantity.is(compatibleWith: HKUnit.meter()) {
                 totalDistance = quantity
             }
-            
+
             if type.identifier == HKWorkoutSortIdentifierTotalSwimmingStrokeCount {
                 totalSwimmingStrokeCount = quantity
             }
-            
+
             if type.identifier == HKWorkoutSortIdentifierTotalFlightsClimbed {
                 totalFlightsClimbed = quantity
             }
-            
+
             return HKQuantitySample.init(
                 type: type,
                 quantity: quantity,
@@ -186,21 +153,21 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                 metadata: metadataDeserialized
             )
         }
-        
+
         // if totals are provided override samples
         let rawTotalDistance = totals.distance ?? 0.0
         let rawTotalEnergy = totals.energyBurned ?? 0.0
-        
+
         if rawTotalDistance != 0.0 {
             totalDistance = HKQuantity(unit: .meter(), doubleValue: rawTotalDistance)
         }
         if rawTotalEnergy != 0.0 {
             totalEnergyBurned = HKQuantity(unit: .kilocalorie(), doubleValue: rawTotalEnergy)
         }
-        
+
         // creating workout
         var workout: HKWorkout?
-        
+
         if totalSwimmingStrokeCount != nil {
             workout = HKWorkout.init(
                 activityType: type,
@@ -230,7 +197,7 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                 }
             }
         }
-        
+
         if workout == nil {
             workout = HKWorkout.init(
                 activityType: type,
@@ -242,11 +209,11 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                 metadata: metadataDeserialized
             )
         }
-        
+
         guard let workout = workout else {
             throw RuntimeError.error(withMessage: "Could not create workout")
         }
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 // saving workout, samples and route
@@ -254,11 +221,11 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                     if let error = error {
                         return continuation.resume(throwing: error)
                     }
-                    
+
                     if initializedSamples.isEmpty {
                         return continuation.resume(returning: workout.uuid.uuidString)
                     }
-                    
+
                     store.add(initializedSamples, to: workout) { (_, error: Error?) in
                         if let error = error {
                             return continuation.resume(throwing: error)
@@ -269,37 +236,19 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
             }
         }
     }
-    
-    
-    func startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration) -> Promise<Bool>
-    {
-        let configuration = parseWorkoutConfiguration(workoutConfiguration)
-        
-        return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                store.startWatchApp(with: configuration) { success, error in
-                    if let error {
-                        continuation.resume(throwing: error)
-                    } else {
-                        continuation.resume(returning: success)
-                    }
-                }
-            }
-        }
-    }
-    
+
     func queryWorkoutSamplesWithAnchor(options: WorkoutQueryOptionsWithAnchor) throws -> Promise<QueryWorkoutSamplesWithAnchorResponse> {
         let predicate = try createPredicateForWorkout(filter: options.filter)
-        
+
         let limit = getQueryLimit(options.limit)
-        
+
         let actualAnchor = try deserializeHKQueryAnchor(base64String: options.anchor)
-        
+
         return Promise.async {
             let energyUnit = try await getUnitToUse(unitOverride: options.energyUnit, quantityType: HKQuantityType(.activeEnergyBurned))
-            
+
             let distanceUnit = try await getUnitToUse(unitOverride: options.energyUnit, quantityType: HKQuantityType(.distanceWalkingRunning))
-            
+
             return try await withCheckedThrowingContinuation { continuation in
                 let q = HKAnchoredObjectQuery(
                     type: .workoutType(),
@@ -317,7 +266,7 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                     if let error = error {
                         return continuation.resume(throwing: error)
                     }
-                    
+
                     guard let samples = s, let newAnchor = newAnchor else {
                         return continuation.resume(
                             throwing: RuntimeError.error(
@@ -325,7 +274,7 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                             )
                         )
                     }
-                    
+
                     let workoutProxies = samples.compactMap { s in
                         if let workout = s as? HKWorkout {
                             return WorkoutProxy.init(
@@ -336,20 +285,20 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                         }
                         return nil
                     }
-                    
+
                     let deletedSamples = deletedSamples?.map({ sample in
                         return serializeDeletedSample(sample: sample)
                     }) ?? []
-                    
+
                     let returnValue = QueryWorkoutSamplesWithAnchorResponse(
                         workouts: workoutProxies,
                         deletedSamples: deletedSamples,
                         newAnchor: serializeAnchor(anchor: newAnchor)!
                     )
-                    
+
                     return continuation.resume(returning: returnValue)
                 }
-                
+
                 store.execute(q)
             }
         }

package/lib/typescript/specs/WorkoutsModule.nitro.d.ts

@@ -9,5 +9,8 @@ export interface WorkoutsModule extends HybridObject<{
     saveWorkoutSample(workoutActivityType: WorkoutActivityType, quantities: readonly QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: WorkoutTotals, metadata: AnyMap): Promise<string>;
     queryWorkoutSamplesWithAnchor(options: WorkoutQueryOptionsWithAnchor): Promise<QueryWorkoutSamplesWithAnchorResponse>;
     queryWorkoutSamples(options: WorkoutQueryOptions): Promise<WorkoutProxy[]>;
+    /**
+     * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1648358-startwatchapp Apple Docs }
+     */
     startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration): Promise<boolean>;
 }

package/nitrogen/generated/ios/ReactNativeHealthkit-Swift-Cxx-Bridge.cpp

@@ -17,7 +17,6 @@
 #include "HybridSourceProxySpecSwift.hpp"
 #include "HybridStateOfMindModuleSpecSwift.hpp"
 #include "HybridWorkoutProxySpecSwift.hpp"
-#include "HybridWorkoutSessionModuleSpecSwift.hpp"
 #include "HybridWorkoutsModuleSpecSwift.hpp"
 #include "ReactNativeHealthkit-Swift-Cxx-Umbrella.hpp"
 
@@ -367,54 +366,14 @@ namespace margelo::nitro::healthkit::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(const std::string& /* errorMessage */)>
+  // pragma MARK: std::function<void(const std::string& /* result */)>
   Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper) {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::string& errorMessage) mutable -> void {
-      swiftClosure.call(errorMessage);
-    };
-  }
-  
-  // pragma MARK: std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>
-  Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point create_Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = ReactNativeHealthkit::Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](WorkoutSessionState toState, WorkoutSessionState fromState, std::chrono::system_clock::time_point date) mutable -> void {
-      swiftClosure.call(static_cast<int>(toState), static_cast<int>(fromState), date);
-    };
-  }
-  
-  // pragma MARK: std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>
-  Func_void_std__vector_RemoteSessionSharableData_ create_Func_void_std__vector_RemoteSessionSharableData_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_RemoteSessionSharableData_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::vector<RemoteSessionSharableData>& data) mutable -> void {
-      swiftClosure.call(data);
-    };
-  }
-  
-  // pragma MARK: std::function<void(WorkoutEventType /* type */)>
-  Func_void_WorkoutEventType create_Func_void_WorkoutEventType(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = ReactNativeHealthkit::Func_void_WorkoutEventType::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](WorkoutEventType type) mutable -> void {
-      swiftClosure.call(static_cast<int>(type));
+    return [swiftClosure = std::move(swiftClosure)](const std::string& result) mutable -> void {
+      swiftClosure.call(result);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(void* _Nonnull swiftUnsafePointer) {
-    ReactNativeHealthkit::HybridWorkoutSessionModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridWorkoutSessionModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpecSwift>(swiftPart);
-  }
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
-    if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridWorkoutSessionModuleSpec\" is not implemented in Swift!");
-    }
-  #endif
-    ReactNativeHealthkit::HybridWorkoutSessionModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
-    return swiftPart.toUnsafe();
-  }
-  
   // pragma MARK: std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>
   Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) {
     auto swiftClosure = ReactNativeHealthkit::Func_void_QueryWorkoutSamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);

package/nitrogen/generated/ios/ReactNativeHealthkit-Swift-Cxx-Bridge.hpp

@@ -66,8 +66,6 @@ namespace margelo::nitro::healthkit { class HybridSourceProxySpec; }
 namespace margelo::nitro::healthkit { class HybridStateOfMindModuleSpec; }
 // Forward declaration of `HybridWorkoutProxySpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutProxySpec; }
-// Forward declaration of `HybridWorkoutSessionModuleSpec` to properly resolve imports.
-namespace margelo::nitro::healthkit { class HybridWorkoutSessionModuleSpec; }
 // Forward declaration of `HybridWorkoutsModuleSpec` to properly resolve imports.
 namespace margelo::nitro::healthkit { class HybridWorkoutsModuleSpec; }
 // Forward declaration of `IdentifierWithUnit` to properly resolve imports.
@@ -112,8 +110,6 @@ namespace margelo::nitro::healthkit { struct QueryOptionsWithSortOrder; }
 namespace margelo::nitro::healthkit { struct QueryStatisticsResponse; }
 // Forward declaration of `QueryWorkoutSamplesWithAnchorResponse` to properly resolve imports.
 namespace margelo::nitro::healthkit { struct QueryWorkoutSamplesWithAnchorResponse; }
-// Forward declaration of `RemoteSessionSharableData` to properly resolve imports.
-namespace margelo::nitro::healthkit { struct RemoteSessionSharableData; }
 // Forward declaration of `SampleTypeIdentifierWriteable` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class SampleTypeIdentifierWriteable; }
 // Forward declaration of `SampleTypeIdentifier` to properly resolve imports.
@@ -160,8 +156,6 @@ namespace margelo::nitro::healthkit { struct WorkoutRoute; }
 namespace margelo::nitro::healthkit { struct WorkoutSample; }
 // Forward declaration of `WorkoutSessionLocationType` to properly resolve imports.
 namespace margelo::nitro::healthkit { enum class WorkoutSessionLocationType; }
-// Forward declaration of `WorkoutSessionState` to properly resolve imports.
-namespace margelo::nitro::healthkit { enum class WorkoutSessionState; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridCategoryTypeModuleSpec_cxx` to properly resolve imports.
@@ -182,8 +176,6 @@ namespace ReactNativeHealthkit { class HybridSourceProxySpec_cxx; }
 namespace ReactNativeHealthkit { class HybridStateOfMindModuleSpec_cxx; }
 // Forward declaration of `HybridWorkoutProxySpec_cxx` to properly resolve imports.
 namespace ReactNativeHealthkit { class HybridWorkoutProxySpec_cxx; }
-// Forward declaration of `HybridWorkoutSessionModuleSpec_cxx` to properly resolve imports.
-namespace ReactNativeHealthkit { class HybridWorkoutSessionModuleSpec_cxx; }
 // Forward declaration of `HybridWorkoutsModuleSpec_cxx` to properly resolve imports.
 namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 
@@ -216,7 +208,6 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "HybridSourceProxySpec.hpp"
 #include "HybridStateOfMindModuleSpec.hpp"
 #include "HybridWorkoutProxySpec.hpp"
-#include "HybridWorkoutSessionModuleSpec.hpp"
 #include "HybridWorkoutsModuleSpec.hpp"
 #include "IdentifierWithUnit.hpp"
 #include "LocationForSaving.hpp"
@@ -239,7 +230,6 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "QueryOptionsWithSortOrderAndUnit.hpp"
 #include "QueryStatisticsResponse.hpp"
 #include "QueryWorkoutSamplesWithAnchorResponse.hpp"
-#include "RemoteSessionSharableData.hpp"
 #include "SampleTypeIdentifier.hpp"
 #include "SampleTypeIdentifierWriteable.hpp"
 #include "Source.hpp"
@@ -263,7 +253,6 @@ namespace ReactNativeHealthkit { class HybridWorkoutsModuleSpec_cxx; }
 #include "WorkoutRouteLocation.hpp"
 #include "WorkoutSample.hpp"
 #include "WorkoutSessionLocationType.hpp"
-#include "WorkoutSessionState.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
@@ -2147,138 +2136,40 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<WorkoutRoute>>>>::withError(error);
   }
   
-  // pragma MARK: std::optional<WorkoutSessionLocationType>
+  // pragma MARK: std::shared_ptr<Promise<std::string>>
   /**
-   * Specialized version of `std::optional<WorkoutSessionLocationType>`.
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
    */
-  using std__optional_WorkoutSessionLocationType_ = std::optional<WorkoutSessionLocationType>;
-  inline std::optional<WorkoutSessionLocationType> create_std__optional_WorkoutSessionLocationType_(const WorkoutSessionLocationType& value) {
-    return std::optional<WorkoutSessionLocationType>(value);
+  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
+  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() {
+    return Promise<std::string>::create();
+  }
+  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) {
+    return PromiseHolder<std::string>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::string& /* errorMessage */)>
+  // pragma MARK: std::function<void(const std::string& /* result */)>
   /**
    * Specialized version of `std::function<void(const std::string&)>`.
    */
-  using Func_void_std__string = std::function<void(const std::string& /* errorMessage */)>;
+  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::string& / * errorMessage * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
    */
   class Func_void_std__string_Wrapper final {
   public:
-    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* errorMessage */)>&& func): _function(std::make_shared<std::function<void(const std::string& /* errorMessage */)>>(std::move(func))) {}
-    inline void call(std::string errorMessage) const {
-      _function->operator()(errorMessage);
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
+    inline void call(std::string result) const {
+      _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::string& /* errorMessage */)>> _function;
+    std::shared_ptr<std::function<void(const std::string& /* result */)>> _function;
   };
   Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper);
   inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) {
     return Func_void_std__string_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>
-  /**
-   * Specialized version of `std::function<void(WorkoutSessionState, WorkoutSessionState, std::chrono::system_clock::time_point)>`.
-   */
-  using Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point = std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>;
-  /**
-   * Wrapper class for a `std::function<void(WorkoutSessionState / * toState * /, WorkoutSessionState / * fromState * /, std::chrono::system_clock::time_point / * date * /)>`, this can be used from Swift.
-   */
-  class Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point_Wrapper final {
-  public:
-    explicit Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point_Wrapper(std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>&& func): _function(std::make_shared<std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>>(std::move(func))) {}
-    inline void call(int toState, int fromState, std::chrono::system_clock::time_point date) const {
-      _function->operator()(static_cast<WorkoutSessionState>(toState), static_cast<WorkoutSessionState>(fromState), date);
-    }
-  private:
-    std::shared_ptr<std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>> _function;
-  };
-  Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point create_Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point_Wrapper wrap_Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point(Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point value) {
-    return Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::vector<RemoteSessionSharableData>
-  /**
-   * Specialized version of `std::vector<RemoteSessionSharableData>`.
-   */
-  using std__vector_RemoteSessionSharableData_ = std::vector<RemoteSessionSharableData>;
-  inline std::vector<RemoteSessionSharableData> create_std__vector_RemoteSessionSharableData_(size_t size) {
-    std::vector<RemoteSessionSharableData> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
-  // pragma MARK: std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>
-  /**
-   * Specialized version of `std::function<void(const std::vector<RemoteSessionSharableData>&)>`.
-   */
-  using Func_void_std__vector_RemoteSessionSharableData_ = std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::vector<RemoteSessionSharableData>& / * data * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__vector_RemoteSessionSharableData__Wrapper final {
-  public:
-    explicit Func_void_std__vector_RemoteSessionSharableData__Wrapper(std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>&& func): _function(std::make_shared<std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>>(std::move(func))) {}
-    inline void call(std::vector<RemoteSessionSharableData> data) const {
-      _function->operator()(data);
-    }
-  private:
-    std::shared_ptr<std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>> _function;
-  };
-  Func_void_std__vector_RemoteSessionSharableData_ create_Func_void_std__vector_RemoteSessionSharableData_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_RemoteSessionSharableData__Wrapper wrap_Func_void_std__vector_RemoteSessionSharableData_(Func_void_std__vector_RemoteSessionSharableData_ value) {
-    return Func_void_std__vector_RemoteSessionSharableData__Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::function<void(WorkoutEventType /* type */)>
-  /**
-   * Specialized version of `std::function<void(WorkoutEventType)>`.
-   */
-  using Func_void_WorkoutEventType = std::function<void(WorkoutEventType /* type */)>;
-  /**
-   * Wrapper class for a `std::function<void(WorkoutEventType / * type * /)>`, this can be used from Swift.
-   */
-  class Func_void_WorkoutEventType_Wrapper final {
-  public:
-    explicit Func_void_WorkoutEventType_Wrapper(std::function<void(WorkoutEventType /* type */)>&& func): _function(std::make_shared<std::function<void(WorkoutEventType /* type */)>>(std::move(func))) {}
-    inline void call(int type) const {
-      _function->operator()(static_cast<WorkoutEventType>(type));
-    }
-  private:
-    std::shared_ptr<std::function<void(WorkoutEventType /* type */)>> _function;
-  };
-  Func_void_WorkoutEventType create_Func_void_WorkoutEventType(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_WorkoutEventType_Wrapper wrap_Func_void_WorkoutEventType(Func_void_WorkoutEventType value) {
-    return Func_void_WorkoutEventType_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>
-  /**
-   * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>`.
-   */
-  using std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ = std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>;
-  std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>
-  using std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ = std::weak_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>;
-  inline std__weak_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ weakify_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(const std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>& strong) { return strong; }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::string>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
-   */
-  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
-  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() {
-    return Promise<std::string>::create();
-  }
-  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) {
-    return PromiseHolder<std::string>(std::move(promise));
-  }
-  
   // pragma MARK: std::vector<QuantitySampleForSaving>
   /**
    * Specialized version of `std::vector<QuantitySampleForSaving>`.
@@ -2519,6 +2410,15 @@ namespace margelo::nitro::healthkit::bridge::swift {
     return Func_void_std__vector_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutProxySpec___Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<WorkoutSessionLocationType>
+  /**
+   * Specialized version of `std::optional<WorkoutSessionLocationType>`.
+   */
+  using std__optional_WorkoutSessionLocationType_ = std::optional<WorkoutSessionLocationType>;
+  inline std::optional<WorkoutSessionLocationType> create_std__optional_WorkoutSessionLocationType_(const WorkoutSessionLocationType& value) {
+    return std::optional<WorkoutSessionLocationType>(value);
+  }
+  
   // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>
   /**
    * Specialized version of `std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutsModuleSpec>`.