react-native-nitro-pose-exercises 1.1.6 → 1.1.7

package/nitrogen/generated/android/c++/JCameraAngleType.hpp

@@ -0,0 +1,58 @@
+///
+/// JCameraAngleType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "CameraAngleType.hpp"
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "CameraAngleType" and the the Kotlin enum "CameraAngleType".
+   */
+  struct JCameraAngleType final: public jni::JavaClass<JCameraAngleType> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/CameraAngleType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum CameraAngleType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CameraAngleType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<CameraAngleType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JCameraAngleType> fromCpp(CameraAngleType value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case CameraAngleType::SIDE:
+          static const auto fieldSIDE = clazz->getStaticField<JCameraAngleType>("SIDE");
+          return clazz->getStaticFieldValue(fieldSIDE);
+        case CameraAngleType::FRONT:
+          static const auto fieldFRONT = clazz->getStaticField<JCameraAngleType>("FRONT");
+          return clazz->getStaticFieldValue(fieldFRONT);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

package/nitrogen/generated/android/c++/JExerciseConfig.hpp

@@ -11,17 +11,21 @@
 #include "ExerciseConfig.hpp"
 
 #include "AngleDefinition.hpp"
+#include "CameraAngleType.hpp"
 #include "ExercisePhase.hpp"
 #include "ExerciseType.hpp"
 #include "FormRule.hpp"
 #include "FormSeverity.hpp"
 #include "JAngleDefinition.hpp"
+#include "JCameraAngleType.hpp"
 #include "JExercisePhase.hpp"
 #include "JExerciseType.hpp"
 #include "JFormRule.hpp"
 #include "JFormSeverity.hpp"
 #include "JPhaseThreshold.hpp"
+#include "JPostureFamily.hpp"
 #include "PhaseThreshold.hpp"
+#include "PostureFamily.hpp"
 #include <string>
 #include <vector>
 
@@ -58,6 +62,12 @@ namespace margelo::nitro::nitroposeexercises {
       jni::local_ref<jni::JArrayClass<JFormRule>> formRules = this->getFieldValue(fieldFormRules);
       static const auto fieldHoldDurationMs = clazz->getField<double>("holdDurationMs");
       double holdDurationMs = this->getFieldValue(fieldHoldDurationMs);
+      static const auto fieldPostureFamily = clazz->getField<JPostureFamily>("postureFamily");
+      jni::local_ref<JPostureFamily> postureFamily = this->getFieldValue(fieldPostureFamily);
+      static const auto fieldVisibilityThreshold = clazz->getField<double>("visibilityThreshold");
+      double visibilityThreshold = this->getFieldValue(fieldVisibilityThreshold);
+      static const auto fieldCameraAngle = clazz->getField<JCameraAngleType>("cameraAngle");
+      jni::local_ref<JCameraAngleType> cameraAngle = this->getFieldValue(fieldCameraAngle);
       return ExerciseConfig(
         name->toStdString(),
         type->toCpp(),
@@ -101,7 +111,10 @@ namespace margelo::nitro::nitroposeexercises {
           }
           return __vector;
         }(formRules),
-        holdDurationMs
+        holdDurationMs,
+        postureFamily->toCpp(),
+        visibilityThreshold,
+        cameraAngle->toCpp()
       );
     }
 
@@ -111,7 +124,7 @@ namespace margelo::nitro::nitroposeexercises {
      */
     [[maybe_unused]]
     static jni::local_ref<JExerciseConfig::javaobject> fromCpp(const ExerciseConfig& value) {
-      using JSignature = JExerciseConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JExerciseType>, jni::alias_ref<jni::JArrayClass<JAngleDefinition>>, jni::alias_ref<jni::JArrayClass<JPhaseThreshold>>, jni::alias_ref<jni::JArrayClass<JExercisePhase>>, jni::alias_ref<jni::JArrayClass<JFormRule>>, double);
+      using JSignature = JExerciseConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JExerciseType>, jni::alias_ref<jni::JArrayClass<JAngleDefinition>>, jni::alias_ref<jni::JArrayClass<JPhaseThreshold>>, jni::alias_ref<jni::JArrayClass<JExercisePhase>>, jni::alias_ref<jni::JArrayClass<JFormRule>>, double, jni::alias_ref<JPostureFamily>, double, jni::alias_ref<JCameraAngleType>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -158,7 +171,10 @@ namespace margelo::nitro::nitroposeexercises {
           }
           return __array;
         }(value.formRules),
-        value.holdDurationMs
+        value.holdDurationMs,
+        JPostureFamily::fromCpp(value.postureFamily),
+        value.visibilityThreshold,
+        JCameraAngleType::fromCpp(value.cameraAngle)
       );
     }
   };

package/nitrogen/generated/android/c++/JHybridNitroPoseExercisesSpec.cpp

@@ -35,6 +35,10 @@ namespace margelo::nitro::nitroposeexercises { struct AngleDefinition; }
 namespace margelo::nitro::nitroposeexercises { struct PhaseThreshold; }
 // Forward declaration of `FormRule` to properly resolve imports.
 namespace margelo::nitro::nitroposeexercises { struct FormRule; }
+// Forward declaration of `PostureFamily` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class PostureFamily; }
+// Forward declaration of `CameraAngleType` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class CameraAngleType; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
 
@@ -80,6 +84,10 @@ namespace margelo::nitro::camera { class HybridFrameSpec; }
 #include "JPhaseThreshold.hpp"
 #include "FormRule.hpp"
 #include "JFormRule.hpp"
+#include "PostureFamily.hpp"
+#include "JPostureFamily.hpp"
+#include "CameraAngleType.hpp"
+#include "JCameraAngleType.hpp"
 #include <memory>
 #include <VisionCamera/HybridFrameSpec.hpp>
 #include <VisionCamera/JHybridFrameSpec.hpp>
@@ -238,6 +246,40 @@ namespace margelo::nitro::nitroposeexercises {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_SessionResult::javaobject> /* onSessionComplete */)>("setOnSessionComplete_cxx");
     method(_javaPart, onSessionComplete.has_value() ? JFunc_void_SessionResult_cxx::fromCpp(onSessionComplete.value()) : nullptr);
   }
+  std::optional<std::function<void()>> JHybridNitroPoseExercisesSpec::getOnPostureLost() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnPostureLost_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroPoseExercisesSpec::setOnPostureLost(const std::optional<std::function<void()>>& onPostureLost) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onPostureLost */)>("setOnPostureLost_cxx");
+    method(_javaPart, onPostureLost.has_value() ? JFunc_void_cxx::fromCpp(onPostureLost.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridNitroPoseExercisesSpec::getOnPostureRegained() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnPostureRegained_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNitroPoseExercisesSpec::setOnPostureRegained(const std::optional<std::function<void()>>& onPostureRegained) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onPostureRegained */)>("setOnPostureRegained_cxx");
+    method(_javaPart, onPostureRegained.has_value() ? JFunc_void_cxx::fromCpp(onPostureRegained.value()) : nullptr);
+  }
   ExercisePhase JHybridNitroPoseExercisesSpec::getCurrentPhase() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JExercisePhase>()>("getCurrentPhase");
     auto __result = method(_javaPart);
@@ -307,5 +349,10 @@ namespace margelo::nitro::nitroposeexercises {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("stopSession");
     method(_javaPart);
   }
+  bool JHybridNitroPoseExercisesSpec::isReady() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isReady");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
 
 } // namespace margelo::nitro::nitroposeexercises

package/nitrogen/generated/android/c++/JHybridNitroPoseExercisesSpec.hpp

@@ -65,6 +65,10 @@ namespace margelo::nitro::nitroposeexercises {
     void setOnPoseRegained(const std::optional<std::function<void()>>& onPoseRegained) override;
     std::optional<std::function<void(const SessionResult& /* result */)>> getOnSessionComplete() override;
     void setOnSessionComplete(const std::optional<std::function<void(const SessionResult& /* result */)>>& onSessionComplete) override;
+    std::optional<std::function<void()>> getOnPostureLost() override;
+    void setOnPostureLost(const std::optional<std::function<void()>>& onPostureLost) override;
+    std::optional<std::function<void()>> getOnPostureRegained() override;
+    void setOnPostureRegained(const std::optional<std::function<void()>>& onPostureRegained) override;
     ExercisePhase getCurrentPhase() override;
     double getRepCount() override;
     std::vector<Landmark> getLandmarks() override;
@@ -79,6 +83,7 @@ namespace margelo::nitro::nitroposeexercises {
     void pauseSession() override;
     void resumeSession() override;
     void stopSession() override;
+    bool isReady() override;
 
   private:
     jni::global_ref<JHybridNitroPoseExercisesSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/c++/JPostureFamily.hpp

@@ -0,0 +1,73 @@
+///
+/// JPostureFamily.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PostureFamily.hpp"
+
+namespace margelo::nitro::nitroposeexercises {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "PostureFamily" and the the Kotlin enum "PostureFamily".
+   */
+  struct JPostureFamily final: public jni::JavaClass<JPostureFamily> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitroposeexercises/PostureFamily;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum PostureFamily.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PostureFamily toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<PostureFamily>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JPostureFamily> fromCpp(PostureFamily value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case PostureFamily::HORIZONTALPRONE:
+          static const auto fieldHORIZONTALPRONE = clazz->getStaticField<JPostureFamily>("HORIZONTALPRONE");
+          return clazz->getStaticFieldValue(fieldHORIZONTALPRONE);
+        case PostureFamily::STANDINGUPRIGHT:
+          static const auto fieldSTANDINGUPRIGHT = clazz->getStaticField<JPostureFamily>("STANDINGUPRIGHT");
+          return clazz->getStaticFieldValue(fieldSTANDINGUPRIGHT);
+        case PostureFamily::SEATED:
+          static const auto fieldSEATED = clazz->getStaticField<JPostureFamily>("SEATED");
+          return clazz->getStaticFieldValue(fieldSEATED);
+        case PostureFamily::INVERTED:
+          static const auto fieldINVERTED = clazz->getStaticField<JPostureFamily>("INVERTED");
+          return clazz->getStaticFieldValue(fieldINVERTED);
+        case PostureFamily::SIDEPLANK:
+          static const auto fieldSIDEPLANK = clazz->getStaticField<JPostureFamily>("SIDEPLANK");
+          return clazz->getStaticFieldValue(fieldSIDEPLANK);
+        case PostureFamily::SUPINE:
+          static const auto fieldSUPINE = clazz->getStaticField<JPostureFamily>("SUPINE");
+          return clazz->getStaticFieldValue(fieldSUPINE);
+        case PostureFamily::NONE:
+          static const auto fieldNONE = clazz->getStaticField<JPostureFamily>("NONE");
+          return clazz->getStaticFieldValue(fieldNONE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroposeexercises

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroposeexercises/CameraAngleType.kt

@@ -0,0 +1,23 @@
+///
+/// CameraAngleType.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroposeexercises
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "CameraAngleType".
+ */
+@DoNotStrip
+@Keep
+enum class CameraAngleType(@DoNotStrip @Keep val value: Int) {
+  SIDE(0),
+  FRONT(1);
+
+  companion object
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroposeexercises/ExerciseConfig.kt

@@ -38,7 +38,16 @@ data class ExerciseConfig(
   val formRules: Array<FormRule>,
   @DoNotStrip
   @Keep
-  val holdDurationMs: Double
+  val holdDurationMs: Double,
+  @DoNotStrip
+  @Keep
+  val postureFamily: PostureFamily,
+  @DoNotStrip
+  @Keep
+  val visibilityThreshold: Double,
+  @DoNotStrip
+  @Keep
+  val cameraAngle: CameraAngleType
 ) {
   /* primary constructor */
 
@@ -52,6 +61,9 @@ data class ExerciseConfig(
       && Objects.deepEquals(this.repSequence, other.repSequence)
       && Objects.deepEquals(this.formRules, other.formRules)
       && Objects.deepEquals(this.holdDurationMs, other.holdDurationMs)
+      && Objects.deepEquals(this.postureFamily, other.postureFamily)
+      && Objects.deepEquals(this.visibilityThreshold, other.visibilityThreshold)
+      && Objects.deepEquals(this.cameraAngle, other.cameraAngle)
   }
 
   override fun hashCode(): Int {
@@ -62,7 +74,10 @@ data class ExerciseConfig(
       phases,
       repSequence,
       formRules,
-      holdDurationMs
+      holdDurationMs,
+      postureFamily,
+      visibilityThreshold,
+      cameraAngle
     ).contentDeepHashCode()
   }
 
@@ -74,8 +89,8 @@ data class ExerciseConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(name: String, type: ExerciseType, angles: Array<AngleDefinition>, phases: Array<PhaseThreshold>, repSequence: Array<ExercisePhase>, formRules: Array<FormRule>, holdDurationMs: Double): ExerciseConfig {
-      return ExerciseConfig(name, type, angles, phases, repSequence, formRules, holdDurationMs)
+    private fun fromCpp(name: String, type: ExerciseType, angles: Array<AngleDefinition>, phases: Array<PhaseThreshold>, repSequence: Array<ExercisePhase>, formRules: Array<FormRule>, holdDurationMs: Double, postureFamily: PostureFamily, visibilityThreshold: Double, cameraAngle: CameraAngleType): ExerciseConfig {
+      return ExerciseConfig(name, type, angles, phases, repSequence, formRules, holdDurationMs, postureFamily, visibilityThreshold, cameraAngle)
     }
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroposeexercises/HybridNitroPoseExercisesSpec.kt

@@ -129,6 +129,34 @@ abstract class HybridNitroPoseExercisesSpec: HybridObject() {
       onSessionComplete = value?.let { it }
     }
   
+  abstract var onPostureLost: (() -> Unit)?
+  
+  private var onPostureLost_cxx: Func_void?
+    @Keep
+    @DoNotStrip
+    get() {
+      return onPostureLost?.let { Func_void_java(it) }
+    }
+    @Keep
+    @DoNotStrip
+    set(value) {
+      onPostureLost = value?.let { it }
+    }
+  
+  abstract var onPostureRegained: (() -> Unit)?
+  
+  private var onPostureRegained_cxx: Func_void?
+    @Keep
+    @DoNotStrip
+    get() {
+      return onPostureRegained?.let { Func_void_java(it) }
+    }
+    @Keep
+    @DoNotStrip
+    set(value) {
+      onPostureRegained = value?.let { it }
+    }
+  
   @get:DoNotStrip
   @get:Keep
   abstract val currentPhase: ExercisePhase
@@ -173,6 +201,10 @@ abstract class HybridNitroPoseExercisesSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun stopSession(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun isReady(): Boolean
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroposeexercises/PostureFamily.kt

@@ -0,0 +1,28 @@
+///
+/// PostureFamily.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroposeexercises
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "PostureFamily".
+ */
+@DoNotStrip
+@Keep
+enum class PostureFamily(@DoNotStrip @Keep val value: Int) {
+  HORIZONTALPRONE(0),
+  STANDINGUPRIGHT(1),
+  SEATED(2),
+  INVERTED(3),
+  SIDEPLANK(4),
+  SUPINE(5),
+  NONE(6);
+
+  companion object
+}

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

@@ -445,5 +445,14 @@ namespace margelo::nitro::nitroposeexercises::bridge::swift {
   inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
     return Result<void>::withError(error);
   }
+  
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
+  }
 
 } // namespace margelo::nitro::nitroposeexercises::bridge::swift

package/nitrogen/generated/ios/NitroPoseExercises-Swift-Cxx-Umbrella.hpp

@@ -12,6 +12,8 @@
 namespace margelo::nitro::nitroposeexercises { struct AngleDefinition; }
 // Forward declaration of `AngleSnapshot` to properly resolve imports.
 namespace margelo::nitro::nitroposeexercises { struct AngleSnapshot; }
+// Forward declaration of `CameraAngleType` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class CameraAngleType; }
 // Forward declaration of `ExerciseConfig` to properly resolve imports.
 namespace margelo::nitro::nitroposeexercises { struct ExerciseConfig; }
 // Forward declaration of `ExercisePhase` to properly resolve imports.
@@ -34,6 +36,8 @@ namespace margelo::nitro::nitroposeexercises { class HybridNitroPoseExercisesSpe
 namespace margelo::nitro::nitroposeexercises { struct Landmark; }
 // Forward declaration of `PhaseThreshold` to properly resolve imports.
 namespace margelo::nitro::nitroposeexercises { struct PhaseThreshold; }
+// Forward declaration of `PostureFamily` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class PostureFamily; }
 // Forward declaration of `RepData` to properly resolve imports.
 namespace margelo::nitro::nitroposeexercises { struct RepData; }
 // Forward declaration of `SessionResult` to properly resolve imports.
@@ -44,6 +48,7 @@ namespace margelo::nitro::nitroposeexercises { enum class SessionStatus; }
 // Include C++ defined types
 #include "AngleDefinition.hpp"
 #include "AngleSnapshot.hpp"
+#include "CameraAngleType.hpp"
 #include "ExerciseConfig.hpp"
 #include "ExercisePhase.hpp"
 #include "ExerciseType.hpp"
@@ -54,6 +59,7 @@ namespace margelo::nitro::nitroposeexercises { enum class SessionStatus; }
 #include "HybridNitroPoseExercisesSpec.hpp"
 #include "Landmark.hpp"
 #include "PhaseThreshold.hpp"
+#include "PostureFamily.hpp"
 #include "RepData.hpp"
 #include "SessionResult.hpp"
 #include "SessionStatus.hpp"

package/nitrogen/generated/ios/c++/HybridNitroPoseExercisesSpecSwift.hpp

@@ -40,6 +40,10 @@ namespace margelo::nitro::nitroposeexercises { struct AngleDefinition; }
 namespace margelo::nitro::nitroposeexercises { struct PhaseThreshold; }
 // Forward declaration of `FormRule` to properly resolve imports.
 namespace margelo::nitro::nitroposeexercises { struct FormRule; }
+// Forward declaration of `PostureFamily` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class PostureFamily; }
+// Forward declaration of `CameraAngleType` to properly resolve imports.
+namespace margelo::nitro::nitroposeexercises { enum class CameraAngleType; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
 
@@ -62,6 +66,8 @@ namespace margelo::nitro::camera { class HybridFrameSpec; }
 #include "AngleDefinition.hpp"
 #include "PhaseThreshold.hpp"
 #include "FormRule.hpp"
+#include "PostureFamily.hpp"
+#include "CameraAngleType.hpp"
 #include <memory>
 #include <VisionCamera/HybridFrameSpec.hpp>
 
@@ -164,6 +170,20 @@ namespace margelo::nitro::nitroposeexercises {
     inline void setOnSessionComplete(const std::optional<std::function<void(const SessionResult& /* result */)>>& onSessionComplete) noexcept override {
       _swiftPart.setOnSessionComplete(onSessionComplete);
     }
+    inline std::optional<std::function<void()>> getOnPostureLost() noexcept override {
+      auto __result = _swiftPart.getOnPostureLost();
+      return __result;
+    }
+    inline void setOnPostureLost(const std::optional<std::function<void()>>& onPostureLost) noexcept override {
+      _swiftPart.setOnPostureLost(onPostureLost);
+    }
+    inline std::optional<std::function<void()>> getOnPostureRegained() noexcept override {
+      auto __result = _swiftPart.getOnPostureRegained();
+      return __result;
+    }
+    inline void setOnPostureRegained(const std::optional<std::function<void()>>& onPostureRegained) noexcept override {
+      _swiftPart.setOnPostureRegained(onPostureRegained);
+    }
     inline ExercisePhase getCurrentPhase() noexcept override {
       auto __result = _swiftPart.getCurrentPhase();
       return static_cast<ExercisePhase>(__result);
@@ -228,6 +248,14 @@ namespace margelo::nitro::nitroposeexercises {
         std::rethrow_exception(__result.error());
       }
     }
+    inline bool isReady() override {
+      auto __result = _swiftPart.isReady();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroPoseExercises::HybridNitroPoseExercisesSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/CameraAngleType.swift

@@ -0,0 +1,40 @@
+///
+/// CameraAngleType.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `CameraAngleType`, backed by a C++ enum.
+ */
+public typealias CameraAngleType = margelo.nitro.nitroposeexercises.CameraAngleType
+
+public extension CameraAngleType {
+  /**
+   * Get a CameraAngleType for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "side":
+        self = .side
+      case "front":
+        self = .front
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this CameraAngleType represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .side:
+        return "side"
+      case .front:
+        return "front"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/ExerciseConfig.swift

@@ -18,7 +18,7 @@ public extension ExerciseConfig {
   /**
    * Create a new instance of `ExerciseConfig`.
    */
-  init(name: String, type: ExerciseType, angles: [AngleDefinition], phases: [PhaseThreshold], repSequence: [ExercisePhase], formRules: [FormRule], holdDurationMs: Double) {
+  init(name: String, type: ExerciseType, angles: [AngleDefinition], phases: [PhaseThreshold], repSequence: [ExercisePhase], formRules: [FormRule], holdDurationMs: Double, postureFamily: PostureFamily, visibilityThreshold: Double, cameraAngle: CameraAngleType) {
     self.init(std.string(name), type, { () -> bridge.std__vector_AngleDefinition_ in
       var __vector = bridge.create_std__vector_AngleDefinition_(angles.count)
       for __item in angles {
@@ -43,7 +43,7 @@ public extension ExerciseConfig {
         __vector.push_back(__item)
       }
       return __vector
-    }(), holdDurationMs)
+    }(), holdDurationMs, postureFamily, visibilityThreshold, cameraAngle)
   }
 
   @inline(__always)
@@ -80,4 +80,19 @@ public extension ExerciseConfig {
   var holdDurationMs: Double {
     return self.__holdDurationMs
   }
+  
+  @inline(__always)
+  var postureFamily: PostureFamily {
+    return self.__postureFamily
+  }
+  
+  @inline(__always)
+  var visibilityThreshold: Double {
+    return self.__visibilityThreshold
+  }
+  
+  @inline(__always)
+  var cameraAngle: CameraAngleType {
+    return self.__cameraAngle
+  }
 }

package/nitrogen/generated/ios/swift/HybridNitroPoseExercisesSpec.swift

@@ -19,6 +19,8 @@ public protocol HybridNitroPoseExercisesSpec_protocol: HybridObject {
   var onPoseLost: (() -> Void)? { get set }
   var onPoseRegained: (() -> Void)? { get set }
   var onSessionComplete: ((_ result: SessionResult) -> Void)? { get set }
+  var onPostureLost: (() -> Void)? { get set }
+  var onPostureRegained: (() -> Void)? { get set }
   var currentPhase: ExercisePhase { get }
   var repCount: Double { get }
   var landmarks: [Landmark] { get }
@@ -32,6 +34,7 @@ public protocol HybridNitroPoseExercisesSpec_protocol: HybridObject {
   func pauseSession() throws -> Void
   func resumeSession() throws -> Void
   func stopSession() throws -> Void
+  func isReady() throws -> Bool
 }
 
 public extension HybridNitroPoseExercisesSpec_protocol {