@neoskola/auto-play 0.2.18 → 0.3.0

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

@@ -20,6 +20,7 @@
 #include "JDistance.hpp"
 #include "JDistanceUnits.hpp"
 #include "JFunc_void.hpp"
+#include "JFunc_void_double_double.hpp"
 #include "JFunc_void_std__optional_bool_.hpp"
 #include "JGlyphImage.hpp"
 #include "JNitroColor.hpp"
@@ -86,6 +87,10 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       jni::local_ref<JFunc_void::javaobject> onSkipBackward = this->getFieldValue(fieldOnSkipBackward);
       static const auto fieldOnComplete = clazz->getField<JFunc_void::javaobject>("onComplete");
       jni::local_ref<JFunc_void::javaobject> onComplete = this->getFieldValue(fieldOnComplete);
+      static const auto fieldOnProgressUpdate = clazz->getField<JFunc_void_double_double::javaobject>("onProgressUpdate");
+      jni::local_ref<JFunc_void_double_double::javaobject> onProgressUpdate = this->getFieldValue(fieldOnProgressUpdate);
+      static const auto fieldOnPlaybackFinished = clazz->getField<JFunc_void::javaobject>("onPlaybackFinished");
+      jni::local_ref<JFunc_void::javaobject> onPlaybackFinished = this->getFieldValue(fieldOnPlaybackFinished);
       return NowPlayingTemplateConfig(
         id->toStdString(),
         onWillAppear != nullptr ? std::make_optional([&]() -> std::function<void(std::optional<bool> /* animated */)> {
@@ -184,6 +189,24 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
             auto onCompleteRef = jni::make_global(onComplete);
             return JNICallable<JFunc_void, void()>(std::move(onCompleteRef));
           }
+        }()) : std::nullopt,
+        onProgressUpdate != nullptr ? std::make_optional([&]() -> std::function<void(double /* currentTime */, double /* duration */)> {
+          if (onProgressUpdate->isInstanceOf(JFunc_void_double_double_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_double_double_cxx::javaobject>(onProgressUpdate);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onProgressUpdateRef = jni::make_global(onProgressUpdate);
+            return JNICallable<JFunc_void_double_double, void(double, double)>(std::move(onProgressUpdateRef));
+          }
+        }()) : std::nullopt,
+        onPlaybackFinished != nullptr ? std::make_optional([&]() -> std::function<void()> {
+          if (onPlaybackFinished->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(onPlaybackFinished);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto onPlaybackFinishedRef = jni::make_global(onPlaybackFinished);
+            return JNICallable<JFunc_void, void()>(std::move(onPlaybackFinishedRef));
+          }
         }()) : std::nullopt
       );
     }
@@ -194,7 +217,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
      */
     [[maybe_unused]]
     static jni::local_ref<JNowPlayingTemplateConfig::javaobject> fromCpp(const NowPlayingTemplateConfig& value) {
-      using JSignature = JNowPlayingTemplateConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JAutoText>, jni::alias_ref<JAutoText>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JVariant_GlyphImage_AssetImage>, jboolean, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void::javaobject>);
+      using JSignature = JNowPlayingTemplateConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JAutoText>, jni::alias_ref<JAutoText>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JVariant_GlyphImage_AssetImage>, jboolean, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void_double_double::javaobject>, jni::alias_ref<JFunc_void::javaobject>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -216,7 +239,9 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         value.onPause.has_value() ? JFunc_void_cxx::fromCpp(value.onPause.value()) : nullptr,
         value.onSkipForward.has_value() ? JFunc_void_cxx::fromCpp(value.onSkipForward.value()) : nullptr,
         value.onSkipBackward.has_value() ? JFunc_void_cxx::fromCpp(value.onSkipBackward.value()) : nullptr,
-        value.onComplete.has_value() ? JFunc_void_cxx::fromCpp(value.onComplete.value()) : nullptr
+        value.onComplete.has_value() ? JFunc_void_cxx::fromCpp(value.onComplete.value()) : nullptr,
+        value.onProgressUpdate.has_value() ? JFunc_void_double_double_cxx::fromCpp(value.onProgressUpdate.value()) : nullptr,
+        value.onPlaybackFinished.has_value() ? JFunc_void_cxx::fromCpp(value.onPlaybackFinished.value()) : nullptr
       );
     }
   };

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_double_double.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_double_double.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(currentTime: number, duration: number) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_double_double: (Double, Double) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(currentTime: Double, duration: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(currentTime: number, duration: number) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_double_double_cxx: Func_void_double_double {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(currentTime: Double, duration: Double): Unit
+    = invoke_cxx(currentTime,duration)
+
+  @FastNative
+  private external fun invoke_cxx(currentTime: Double, duration: Double): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(currentTime: number, duration: number) => void`.
+ * This is implemented in Java/Kotlin, via a `(Double, Double) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_double_double_java(private val function: (Double, Double) -> Unit): Func_void_double_double {
+  @DoNotStrip
+  @Keep
+  override fun invoke(currentTime: Double, duration: Double): Unit {
+    return this.function(currentTime, duration)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridNowPlayingTemplateSpec.kt

@@ -61,6 +61,30 @@ abstract class HybridNowPlayingTemplateSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun updateNowPlayingTemplateElapsedTime(templateId: String, elapsedTime: Double, duration: Double): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun playAudio(templateId: String, url: String, startFrom: Double): Promise<Boolean>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun pauseAudio(templateId: String): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun resumeAudio(templateId: String): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun seekForward(templateId: String, seconds: Double): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun seekBackward(templateId: String, seconds: Double): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun stopAudio(templateId: String): Promise<Unit>
 
   private external fun initHybrid(): HybridData
 

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/NowPlayingTemplateConfig.kt

@@ -70,13 +70,19 @@ data class NowPlayingTemplateConfig(
   val onSkipBackward: Func_void?,
   @DoNotStrip
   @Keep
-  val onComplete: Func_void?
+  val onComplete: Func_void?,
+  @DoNotStrip
+  @Keep
+  val onProgressUpdate: Func_void_double_double?,
+  @DoNotStrip
+  @Keep
+  val onPlaybackFinished: Func_void?
 ) {
   /**
    * Create a new instance of NowPlayingTemplateConfig from Kotlin
    */
-  constructor(id: String, onWillAppear: ((animated: Boolean?) -> Unit)?, onWillDisappear: ((animated: Boolean?) -> Unit)?, onDidAppear: ((animated: Boolean?) -> Unit)?, onDidDisappear: ((animated: Boolean?) -> Unit)?, onPopped: (() -> Unit)?, autoDismissMs: Double?, title: AutoText, subtitle: AutoText?, courseId: String, lessonId: String, image: Variant_GlyphImage_AssetImage?, isPlaying: Boolean, onPlay: (() -> Unit)?, onPause: (() -> Unit)?, onSkipForward: (() -> Unit)?, onSkipBackward: (() -> Unit)?, onComplete: (() -> Unit)?):
-         this(id, onWillAppear?.let { Func_void_std__optional_bool__java(it) }, onWillDisappear?.let { Func_void_std__optional_bool__java(it) }, onDidAppear?.let { Func_void_std__optional_bool__java(it) }, onDidDisappear?.let { Func_void_std__optional_bool__java(it) }, onPopped?.let { Func_void_java(it) }, autoDismissMs, title, subtitle, courseId, lessonId, image, isPlaying, onPlay?.let { Func_void_java(it) }, onPause?.let { Func_void_java(it) }, onSkipForward?.let { Func_void_java(it) }, onSkipBackward?.let { Func_void_java(it) }, onComplete?.let { Func_void_java(it) })
+  constructor(id: String, onWillAppear: ((animated: Boolean?) -> Unit)?, onWillDisappear: ((animated: Boolean?) -> Unit)?, onDidAppear: ((animated: Boolean?) -> Unit)?, onDidDisappear: ((animated: Boolean?) -> Unit)?, onPopped: (() -> Unit)?, autoDismissMs: Double?, title: AutoText, subtitle: AutoText?, courseId: String, lessonId: String, image: Variant_GlyphImage_AssetImage?, isPlaying: Boolean, onPlay: (() -> Unit)?, onPause: (() -> Unit)?, onSkipForward: (() -> Unit)?, onSkipBackward: (() -> Unit)?, onComplete: (() -> Unit)?, onProgressUpdate: ((currentTime: Double, duration: Double) -> Unit)?, onPlaybackFinished: (() -> Unit)?):
+         this(id, onWillAppear?.let { Func_void_std__optional_bool__java(it) }, onWillDisappear?.let { Func_void_std__optional_bool__java(it) }, onDidAppear?.let { Func_void_std__optional_bool__java(it) }, onDidDisappear?.let { Func_void_std__optional_bool__java(it) }, onPopped?.let { Func_void_java(it) }, autoDismissMs, title, subtitle, courseId, lessonId, image, isPlaying, onPlay?.let { Func_void_java(it) }, onPause?.let { Func_void_java(it) }, onSkipForward?.let { Func_void_java(it) }, onSkipBackward?.let { Func_void_java(it) }, onComplete?.let { Func_void_java(it) }, onProgressUpdate?.let { Func_void_double_double_java(it) }, onPlaybackFinished?.let { Func_void_java(it) })
 
   private companion object {
     /**
@@ -86,8 +92,8 @@ data class NowPlayingTemplateConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(id: String, onWillAppear: Func_void_std__optional_bool_?, onWillDisappear: Func_void_std__optional_bool_?, onDidAppear: Func_void_std__optional_bool_?, onDidDisappear: Func_void_std__optional_bool_?, onPopped: Func_void?, autoDismissMs: Double?, title: AutoText, subtitle: AutoText?, courseId: String, lessonId: String, image: Variant_GlyphImage_AssetImage?, isPlaying: Boolean, onPlay: Func_void?, onPause: Func_void?, onSkipForward: Func_void?, onSkipBackward: Func_void?, onComplete: Func_void?): NowPlayingTemplateConfig {
-      return NowPlayingTemplateConfig(id, onWillAppear, onWillDisappear, onDidAppear, onDidDisappear, onPopped, autoDismissMs, title, subtitle, courseId, lessonId, image, isPlaying, onPlay, onPause, onSkipForward, onSkipBackward, onComplete)
+    private fun fromCpp(id: String, onWillAppear: Func_void_std__optional_bool_?, onWillDisappear: Func_void_std__optional_bool_?, onDidAppear: Func_void_std__optional_bool_?, onDidDisappear: Func_void_std__optional_bool_?, onPopped: Func_void?, autoDismissMs: Double?, title: AutoText, subtitle: AutoText?, courseId: String, lessonId: String, image: Variant_GlyphImage_AssetImage?, isPlaying: Boolean, onPlay: Func_void?, onPause: Func_void?, onSkipForward: Func_void?, onSkipBackward: Func_void?, onComplete: Func_void?, onProgressUpdate: Func_void_double_double?, onPlaybackFinished: Func_void?): NowPlayingTemplateConfig {
+      return NowPlayingTemplateConfig(id, onWillAppear, onWillDisappear, onDidAppear, onDidDisappear, onPopped, autoDismissMs, title, subtitle, courseId, lessonId, image, isPlaying, onPlay, onPause, onSkipForward, onSkipBackward, onComplete, onProgressUpdate, onPlaybackFinished)
     }
   }
 }

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

@@ -357,6 +357,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
+  // pragma MARK: std::function<void(double /* currentTime */, double /* duration */)>
+  Func_void_double_double create_Func_void_double_double(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeAutoPlay::Func_void_double_double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](double currentTime, double duration) mutable -> void {
+      swiftClosure.call(currentTime, duration);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridNowPlayingTemplateSpec>
   std::shared_ptr<HybridNowPlayingTemplateSpec> create_std__shared_ptr_HybridNowPlayingTemplateSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeAutoPlay::HybridNowPlayingTemplateSpec_cxx swiftPart = ReactNativeAutoPlay::HybridNowPlayingTemplateSpec_cxx::fromUnsafe(swiftUnsafePointer);

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

@@ -1663,6 +1663,55 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
   using std__weak_ptr_HybridNeoSkolaTemplateSpec_ = std::weak_ptr<HybridNeoSkolaTemplateSpec>;
   inline std__weak_ptr_HybridNeoSkolaTemplateSpec_ weakify_std__shared_ptr_HybridNeoSkolaTemplateSpec_(const std::shared_ptr<HybridNeoSkolaTemplateSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: std::function<void(double /* currentTime */, double /* duration */)>
+  /**
+   * Specialized version of `std::function<void(double, double)>`.
+   */
+  using Func_void_double_double = std::function<void(double /* currentTime */, double /* duration */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * currentTime * /, double / * duration * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_double_Wrapper final {
+  public:
+    explicit Func_void_double_double_Wrapper(std::function<void(double /* currentTime */, double /* duration */)>&& func): _function(std::make_unique<std::function<void(double /* currentTime */, double /* duration */)>>(std::move(func))) {}
+    inline void call(double currentTime, double duration) const noexcept {
+      _function->operator()(currentTime, duration);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* currentTime */, double /* duration */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double_double create_Func_void_double_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_double_Wrapper wrap_Func_void_double_double(Func_void_double_double value) noexcept {
+    return Func_void_double_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(double /* currentTime */, double /* duration */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(double / * currentTime * /, double / * duration * /)>>`.
+   */
+  using std__optional_std__function_void_double____currentTime_____double____duration______ = std::optional<std::function<void(double /* currentTime */, double /* duration */)>>;
+  inline std::optional<std::function<void(double /* currentTime */, double /* duration */)>> create_std__optional_std__function_void_double____currentTime_____double____duration______(const std::function<void(double /* currentTime */, double /* duration */)>& value) noexcept {
+    return std::optional<std::function<void(double /* currentTime */, double /* duration */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_double____currentTime_____double____duration______(const std::optional<std::function<void(double /* currentTime */, double /* duration */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(double /* currentTime */, double /* duration */)> get_std__optional_std__function_void_double____currentTime_____double____duration______(const std::optional<std::function<void(double /* currentTime */, double /* duration */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridNowPlayingTemplateSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridNowPlayingTemplateSpec>`.
@@ -1675,6 +1724,15 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
   using std__weak_ptr_HybridNowPlayingTemplateSpec_ = std::weak_ptr<HybridNowPlayingTemplateSpec>;
   inline std__weak_ptr_HybridNowPlayingTemplateSpec_ weakify_std__shared_ptr_HybridNowPlayingTemplateSpec_(const std::shared_ptr<HybridNowPlayingTemplateSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
+  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
+  }
+  
   // pragma MARK: std::shared_ptr<HybridSearchTemplateSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridSearchTemplateSpec>`.

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

@@ -114,6 +114,54 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<bool>> playAudio(const std::string& templateId, const std::string& url, double startFrom) override {
+      auto __result = _swiftPart.playAudio(templateId, url, std::forward<decltype(startFrom)>(startFrom));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> pauseAudio(const std::string& templateId) override {
+      auto __result = _swiftPart.pauseAudio(templateId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> resumeAudio(const std::string& templateId) override {
+      auto __result = _swiftPart.resumeAudio(templateId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> seekForward(const std::string& templateId, double seconds) override {
+      auto __result = _swiftPart.seekForward(templateId, std::forward<decltype(seconds)>(seconds));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> seekBackward(const std::string& templateId, double seconds) override {
+      auto __result = _swiftPart.seekBackward(templateId, std::forward<decltype(seconds)>(seconds));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> stopAudio(const std::string& templateId) override {
+      auto __result = _swiftPart.stopAudio(templateId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     ReactNativeAutoPlay::HybridNowPlayingTemplateSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/Func_void_bool.swift

@@ -9,21 +9,21 @@ import Foundation
 import NitroModules
 
 /**
- * Wraps a Swift `(_ isPanningInterfaceVisible: Bool) -> Void` as a class.
+ * Wraps a Swift `(_ value: Bool) -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
  */
 public final class Func_void_bool {
   public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
 
-  private let closure: (_ isPanningInterfaceVisible: Bool) -> Void
+  private let closure: (_ value: Bool) -> Void
 
-  public init(_ closure: @escaping (_ isPanningInterfaceVisible: Bool) -> Void) {
+  public init(_ closure: @escaping (_ value: Bool) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(isPanningInterfaceVisible: Bool) -> Void {
-    self.closure(isPanningInterfaceVisible)
+  public func call(value: Bool) -> Void {
+    self.closure(value)
   }
 
   /**

package/nitrogen/generated/ios/swift/Func_void_double_double.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_double_double.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ currentTime: Double, _ duration: Double) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_double_double {
+  public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
+
+  private let closure: (_ currentTime: Double, _ duration: Double) -> Void
+
+  public init(_ closure: @escaping (_ currentTime: Double, _ duration: Double) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(currentTime: Double, duration: Double) -> Void {
+    self.closure(currentTime, duration)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_double_double`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_double_double>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_double_double {
+    return Unmanaged<Func_void_double_double>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridNowPlayingTemplateSpec.swift

@@ -18,6 +18,12 @@ public protocol HybridNowPlayingTemplateSpec_protocol: HybridObject {
   func updateNowPlayingTemplatePlaybackState(templateId: String, isPlaying: Bool) throws -> Promise<Void>
   func updateNowPlayingTemplateInfo(templateId: String, title: String, subtitle: String) throws -> Promise<Void>
   func updateNowPlayingTemplateElapsedTime(templateId: String, elapsedTime: Double, duration: Double) throws -> Promise<Void>
+  func playAudio(templateId: String, url: String, startFrom: Double) throws -> Promise<Bool>
+  func pauseAudio(templateId: String) throws -> Promise<Void>
+  func resumeAudio(templateId: String) throws -> Promise<Void>
+  func seekForward(templateId: String, seconds: Double) throws -> Promise<Void>
+  func seekBackward(templateId: String, seconds: Double) throws -> Promise<Void>
+  func stopAudio(templateId: String) throws -> Promise<Void>
 }
 
 public extension HybridNowPlayingTemplateSpec_protocol {

package/nitrogen/generated/ios/swift/HybridNowPlayingTemplateSpec_cxx.swift

@@ -184,4 +184,118 @@ open class HybridNowPlayingTemplateSpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func playAudio(templateId: std.string, url: std.string, startFrom: Double) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.playAudio(templateId: String(templateId), url: String(url), startFrom: startFrom)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func pauseAudio(templateId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.pauseAudio(templateId: String(templateId))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func resumeAudio(templateId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.resumeAudio(templateId: String(templateId))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func seekForward(templateId: std.string, seconds: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.seekForward(templateId: String(templateId), seconds: seconds)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func seekBackward(templateId: std.string, seconds: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.seekBackward(templateId: String(templateId), seconds: seconds)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func stopAudio(templateId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.stopAudio(templateId: String(templateId))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
 }