@iternio/react-native-auto-play 0.1.16 → 0.2.0-alpha.1

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

@@ -19,7 +19,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   using namespace facebook;
 
   /**
-   * Represents the Java/Kotlin callback `(searchText: String) -> Unit`.
+   * Represents the Java/Kotlin callback `(text: String) -> Unit`.
    * This can be passed around between C++ and Java/Kotlin.
    */
   struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
@@ -30,9 +30,9 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     /**
      * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
      */
-    void invoke(const std::string& searchText) const {
-      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* searchText */)>("invoke");
-      method(self(), jni::make_jstring(searchText));
+    void invoke(const std::string& text) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* text */)>("invoke");
+      method(self(), jni::make_jstring(text));
     }
   };
 
@@ -41,7 +41,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
    */
   class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
   public:
-    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* searchText */)>& func) {
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* text */)>& func) {
       return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
     }
 
@@ -49,13 +49,13 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     /**
      * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
      */
-    void invoke_cxx(jni::alias_ref<jni::JString> searchText) {
-      _func(searchText->toStdString());
+    void invoke_cxx(jni::alias_ref<jni::JString> text) {
+      _func(text->toStdString());
     }
 
   public:
     [[nodiscard]]
-    inline const std::function<void(const std::string& /* searchText */)>& getFunction() const {
+    inline const std::function<void(const std::string& /* text */)>& getFunction() const {
       return _func;
     }
 
@@ -66,11 +66,11 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     }
 
   private:
-    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* searchText */)>& func): _func(func) { }
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* text */)>& func): _func(func) { }
 
   private:
     friend HybridBase;
-    std::function<void(const std::string& /* searchText */)> _func;
+    std::function<void(const std::string& /* text */)> _func;
   };
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -7,6 +7,8 @@
 
 #include "JHybridAndroidAutoTelemetrySpec.hpp"
 
+// Forward declaration of `PermissionRequestResult` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct PermissionRequestResult; }
 // Forward declaration of `Telemetry` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct Telemetry; }
 // Forward declaration of `NumericTelemetryItem` to properly resolve imports.
@@ -15,14 +17,21 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NumericTele
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VehicleTelemetryItem; }
 // Forward declaration of `StringTelemetryItem` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct StringTelemetryItem; }
+// Forward declaration of `BooleanTelemetryItem` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct BooleanTelemetryItem; }
 
 #include <functional>
 #include "JFunc_void.hpp"
 #include <NitroModules/JNICallable.hpp>
+#include "PermissionRequestResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JPermissionRequestResult.hpp"
+#include <string>
+#include <vector>
 #include "Telemetry.hpp"
 #include <optional>
-#include <string>
-#include "JFunc_void_std__optional_Telemetry__std__optional_std__string_.hpp"
+#include "JFunc_void_std__optional_Telemetry_.hpp"
 #include "JTelemetry.hpp"
 #include "NumericTelemetryItem.hpp"
 #include "JNumericTelemetryItem.hpp"
@@ -30,6 +39,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct StringTelem
 #include "JVehicleTelemetryItem.hpp"
 #include "StringTelemetryItem.hpp"
 #include "JStringTelemetryItem.hpp"
+#include "BooleanTelemetryItem.hpp"
+#include "JBooleanTelemetryItem.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -63,9 +74,9 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   
 
   // Methods
-  std::function<void()> JHybridAndroidAutoTelemetrySpec::registerTelemetryListener(const std::function<void(const std::optional<Telemetry>& /* tlm */, const std::optional<std::string>& /* error */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_std__optional_Telemetry__std__optional_std__string_::javaobject> /* callback */)>("registerTelemetryListener_cxx");
-    auto __result = method(_javaPart, JFunc_void_std__optional_Telemetry__std__optional_std__string__cxx::fromCpp(callback));
+  std::function<void()> JHybridAndroidAutoTelemetrySpec::registerTelemetryListener(const std::function<void(const std::optional<Telemetry>& /* tlm */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_std__optional_Telemetry_::javaobject> /* callback */)>("registerTelemetryListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_std__optional_Telemetry__cxx::fromCpp(callback));
     return [&]() -> std::function<void()> {
       if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
         auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
@@ -76,5 +87,30 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       }
     }();
   }
+  std::shared_ptr<Promise<PermissionRequestResult>> JHybridAndroidAutoTelemetrySpec::requestAutomotivePermissions(const std::vector<std::string>& permissions, const std::string& message, const std::string& grantButtonText, const std::optional<std::string>& cancelButtonText) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<jni::JString>> /* permissions */, jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* grantButtonText */, jni::alias_ref<jni::JString> /* cancelButtonText */)>("requestAutomotivePermissions");
+    auto __result = method(_javaPart, [&]() {
+      size_t __size = permissions.size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = permissions[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(), jni::make_jstring(message), jni::make_jstring(grantButtonText), cancelButtonText.has_value() ? jni::make_jstring(cancelButtonText.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<PermissionRequestResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPermissionRequestResult>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -54,7 +54,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
   public:
     // Methods
-    std::function<void()> registerTelemetryListener(const std::function<void(const std::optional<Telemetry>& /* tlm */, const std::optional<std::string>& /* error */)>& callback) override;
+    std::function<void()> registerTelemetryListener(const std::function<void(const std::optional<Telemetry>& /* tlm */)>& callback) override;
+    std::shared_ptr<Promise<PermissionRequestResult>> requestAutomotivePermissions(const std::vector<std::string>& permissions, const std::string& message, const std::string& grantButtonText, const std::optional<std::string>& cancelButtonText) override;
 
   private:
     friend HybridBase;

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

@@ -0,0 +1,133 @@
+///
+/// JHybridSignInTemplateSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridSignInTemplateSpec.hpp"
+
+// Forward declaration of `SignInTemplateConfig` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct SignInTemplateConfig; }
+// Forward declaration of `QrSignIn` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct QrSignIn; }
+// Forward declaration of `PinSignIn` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct PinSignIn; }
+// Forward declaration of `InputSignIn` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct InputSignIn; }
+// Forward declaration of `SignInMethods` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class SignInMethods; }
+// Forward declaration of `KeyboardType` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class KeyboardType; }
+// Forward declaration of `TextInputType` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class TextInputType; }
+// Forward declaration of `NitroAction` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAction; }
+// Forward declaration of `GlyphImage` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct GlyphImage; }
+// Forward declaration of `AssetImage` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct AssetImage; }
+// Forward declaration of `NitroColor` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor; }
+// Forward declaration of `NitroActionType` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroActionType; }
+// Forward declaration of `NitroAlignment` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroAlignment; }
+// Forward declaration of `NitroButtonStyle` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroButtonStyle; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "SignInTemplateConfig.hpp"
+#include "JSignInTemplateConfig.hpp"
+#include <string>
+#include <optional>
+#include <functional>
+#include "JFunc_void_std__optional_bool_.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void.hpp"
+#include "QrSignIn.hpp"
+#include "PinSignIn.hpp"
+#include "InputSignIn.hpp"
+#include <variant>
+#include "JVariant_QrSignIn_PinSignIn_InputSignIn.hpp"
+#include "JQrSignIn.hpp"
+#include "SignInMethods.hpp"
+#include "JSignInMethods.hpp"
+#include "JPinSignIn.hpp"
+#include "JInputSignIn.hpp"
+#include "KeyboardType.hpp"
+#include "JKeyboardType.hpp"
+#include "JFunc_void_std__string.hpp"
+#include "TextInputType.hpp"
+#include "JTextInputType.hpp"
+#include "NitroAction.hpp"
+#include <vector>
+#include "JNitroAction.hpp"
+#include "GlyphImage.hpp"
+#include "AssetImage.hpp"
+#include "JVariant_GlyphImage_AssetImage.hpp"
+#include "JGlyphImage.hpp"
+#include "NitroColor.hpp"
+#include "JNitroColor.hpp"
+#include "JAssetImage.hpp"
+#include "NitroActionType.hpp"
+#include "JNitroActionType.hpp"
+#include "NitroAlignment.hpp"
+#include "JNitroAlignment.hpp"
+#include "NitroButtonStyle.hpp"
+#include "JNitroButtonStyle.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  jni::local_ref<JHybridSignInTemplateSpec::jhybriddata> JHybridSignInTemplateSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridSignInTemplateSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridSignInTemplateSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridSignInTemplateSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridSignInTemplateSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridSignInTemplateSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridSignInTemplateSpec::createSignInTemplate(const SignInTemplateConfig& config) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JSignInTemplateConfig> /* config */)>("createSignInTemplate");
+    method(_javaPart, JSignInTemplateConfig::fromCpp(config));
+  }
+  std::shared_ptr<Promise<void>> JHybridSignInTemplateSpec::updateTemplate(const std::string& templateId, const SignInTemplateConfig& config) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<JSignInTemplateConfig> /* config */)>("updateTemplate");
+    auto __result = method(_javaPart, jni::make_jstring(templateId), JSignInTemplateConfig::fromCpp(config));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -0,0 +1,66 @@
+///
+/// HybridSignInTemplateSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridSignInTemplateSpec.hpp"
+
+
+
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  class JHybridSignInTemplateSpec: public jni::HybridClass<JHybridSignInTemplateSpec, JHybridObject>,
+                                   public virtual HybridSignInTemplateSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridSignInTemplateSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridSignInTemplateSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridSignInTemplateSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridSignInTemplateSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridSignInTemplateSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void createSignInTemplate(const SignInTemplateConfig& config) override;
+    std::shared_ptr<Promise<void>> updateTemplate(const std::string& templateId, const SignInTemplateConfig& config) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridSignInTemplateSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -0,0 +1,103 @@
+///
+/// JInputSignIn.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "InputSignIn.hpp"
+
+#include "JFunc_void_std__string.hpp"
+#include "JKeyboardType.hpp"
+#include "JSignInMethods.hpp"
+#include "JTextInputType.hpp"
+#include "KeyboardType.hpp"
+#include "SignInMethods.hpp"
+#include "TextInputType.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <functional>
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "InputSignIn" and the the Kotlin data class "InputSignIn".
+   */
+  struct JInputSignIn final: public jni::JavaClass<JInputSignIn> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/InputSignIn;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct InputSignIn by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    InputSignIn toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMethod = clazz->getField<JSignInMethods>("method");
+      jni::local_ref<JSignInMethods> method = this->getFieldValue(fieldMethod);
+      static const auto fieldKeyboardType = clazz->getField<JKeyboardType>("keyboardType");
+      jni::local_ref<JKeyboardType> keyboardType = this->getFieldValue(fieldKeyboardType);
+      static const auto fieldHint = clazz->getField<jni::JString>("hint");
+      jni::local_ref<jni::JString> hint = this->getFieldValue(fieldHint);
+      static const auto fieldDefaultValue = clazz->getField<jni::JString>("defaultValue");
+      jni::local_ref<jni::JString> defaultValue = this->getFieldValue(fieldDefaultValue);
+      static const auto fieldErrorMessage = clazz->getField<jni::JString>("errorMessage");
+      jni::local_ref<jni::JString> errorMessage = this->getFieldValue(fieldErrorMessage);
+      static const auto fieldCallback = clazz->getField<JFunc_void_std__string::javaobject>("callback");
+      jni::local_ref<JFunc_void_std__string::javaobject> callback = this->getFieldValue(fieldCallback);
+      static const auto fieldShowKeyboardByDefault = clazz->getField<jni::JBoolean>("showKeyboardByDefault");
+      jni::local_ref<jni::JBoolean> showKeyboardByDefault = this->getFieldValue(fieldShowKeyboardByDefault);
+      static const auto fieldInputType = clazz->getField<JTextInputType>("inputType");
+      jni::local_ref<JTextInputType> inputType = this->getFieldValue(fieldInputType);
+      return InputSignIn(
+        method->toCpp(),
+        keyboardType != nullptr ? std::make_optional(keyboardType->toCpp()) : std::nullopt,
+        hint != nullptr ? std::make_optional(hint->toStdString()) : std::nullopt,
+        defaultValue != nullptr ? std::make_optional(defaultValue->toStdString()) : std::nullopt,
+        errorMessage != nullptr ? std::make_optional(errorMessage->toStdString()) : std::nullopt,
+        [&]() -> std::function<void(const std::string& /* text */)> {
+          if (callback->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(callback);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto callbackRef = jni::make_global(callback);
+            return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(callbackRef));
+          }
+        }(),
+        showKeyboardByDefault != nullptr ? std::make_optional(static_cast<bool>(showKeyboardByDefault->value())) : std::nullopt,
+        inputType->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JInputSignIn::javaobject> fromCpp(const InputSignIn& value) {
+      using JSignature = JInputSignIn(jni::alias_ref<JSignInMethods>, jni::alias_ref<JKeyboardType>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JFunc_void_std__string::javaobject>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JTextInputType>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JSignInMethods::fromCpp(value.method),
+        value.keyboardType.has_value() ? JKeyboardType::fromCpp(value.keyboardType.value()) : nullptr,
+        value.hint.has_value() ? jni::make_jstring(value.hint.value()) : nullptr,
+        value.defaultValue.has_value() ? jni::make_jstring(value.defaultValue.value()) : nullptr,
+        value.errorMessage.has_value() ? jni::make_jstring(value.errorMessage.value()) : nullptr,
+        JFunc_void_std__string_cxx::fromCpp(value.callback),
+        value.showKeyboardByDefault.has_value() ? jni::JBoolean::valueOf(value.showKeyboardByDefault.value()) : nullptr,
+        JTextInputType::fromCpp(value.inputType)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

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

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

@@ -0,0 +1,98 @@
+///
+/// JPermissionRequestResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PermissionRequestResult.hpp"
+
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PermissionRequestResult" and the the Kotlin data class "PermissionRequestResult".
+   */
+  struct JPermissionRequestResult final: public jni::JavaClass<JPermissionRequestResult> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/PermissionRequestResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PermissionRequestResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PermissionRequestResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldGranted = clazz->getField<jni::JArrayClass<jni::JString>>("granted");
+      jni::local_ref<jni::JArrayClass<jni::JString>> granted = this->getFieldValue(fieldGranted);
+      static const auto fieldDenied = clazz->getField<jni::JArrayClass<jni::JString>>("denied");
+      jni::local_ref<jni::JArrayClass<jni::JString>> denied = this->getFieldValue(fieldDenied);
+      return PermissionRequestResult(
+        [&]() {
+          size_t __size = granted->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = granted->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }(),
+        [&]() {
+          size_t __size = denied->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = denied->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPermissionRequestResult::javaobject> fromCpp(const PermissionRequestResult& value) {
+      using JSignature = JPermissionRequestResult(jni::alias_ref<jni::JArrayClass<jni::JString>>, jni::alias_ref<jni::JArrayClass<jni::JString>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        [&]() {
+          size_t __size = value.granted.size();
+          jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.granted[__i];
+            auto __elementJni = jni::make_jstring(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(),
+        [&]() {
+          size_t __size = value.denied.size();
+          jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.denied[__i];
+            auto __elementJni = jni::make_jstring(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }()
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay