aix 0.6.0 → 0.6.1

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

@@ -0,0 +1,70 @@
+///
+/// JAixInputWrapperOnPasteEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AixInputWrapperOnPasteEvent.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::aix {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AixInputWrapperOnPasteEvent" and the the Kotlin data class "AixInputWrapperOnPasteEvent".
+   */
+  struct JAixInputWrapperOnPasteEvent final: public jni::JavaClass<JAixInputWrapperOnPasteEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/aix/AixInputWrapperOnPasteEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AixInputWrapperOnPasteEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AixInputWrapperOnPasteEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldType = clazz->getField<jni::JString>("type");
+      jni::local_ref<jni::JString> type = this->getFieldValue(fieldType);
+      static const auto fieldFilePath = clazz->getField<jni::JString>("filePath");
+      jni::local_ref<jni::JString> filePath = this->getFieldValue(fieldFilePath);
+      static const auto fieldFileExtension = clazz->getField<jni::JString>("fileExtension");
+      jni::local_ref<jni::JString> fileExtension = this->getFieldValue(fieldFileExtension);
+      static const auto fieldFileName = clazz->getField<jni::JString>("fileName");
+      jni::local_ref<jni::JString> fileName = this->getFieldValue(fieldFileName);
+      return AixInputWrapperOnPasteEvent(
+        type->toStdString(),
+        filePath->toStdString(),
+        fileExtension != nullptr ? std::make_optional(fileExtension->toStdString()) : std::nullopt,
+        fileName != nullptr ? std::make_optional(fileName->toStdString()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JAixInputWrapperOnPasteEvent::javaobject> fromCpp(const AixInputWrapperOnPasteEvent& value) {
+      using JSignature = JAixInputWrapperOnPasteEvent(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.type),
+        jni::make_jstring(value.filePath),
+        value.fileExtension.has_value() ? jni::make_jstring(value.fileExtension.value()) : nullptr,
+        value.fileName.has_value() ? jni::make_jstring(value.fileName.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::aix

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

@@ -0,0 +1,98 @@
+///
+/// JFunc_void_std__vector_AixInputWrapperOnPasteEvent_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "AixInputWrapperOnPasteEvent.hpp"
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JAixInputWrapperOnPasteEvent.hpp"
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::aix {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(events: Array<AixInputWrapperOnPasteEvent>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_AixInputWrapperOnPasteEvent_: public jni::JavaClass<JFunc_void_std__vector_AixInputWrapperOnPasteEvent_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/aix/Func_void_std__vector_AixInputWrapperOnPasteEvent_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_AixInputWrapperOnPasteEvent_` instance holds through JNI.
+     */
+    void invoke(const std::vector<AixInputWrapperOnPasteEvent>& events) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JAixInputWrapperOnPasteEvent>> /* events */)>("invoke");
+      method(self(), [&]() {
+        size_t __size = events.size();
+        jni::local_ref<jni::JArrayClass<JAixInputWrapperOnPasteEvent>> __array = jni::JArrayClass<JAixInputWrapperOnPasteEvent>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = events[__i];
+          auto __elementJni = JAixInputWrapperOnPasteEvent::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }());
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_AixInputWrapperOnPasteEvent_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx final: public jni::HybridClass<JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx, JFunc_void_std__vector_AixInputWrapperOnPasteEvent_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_AixInputWrapperOnPasteEvent_::javaobject> fromCpp(const std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>& func) {
+      return JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JAixInputWrapperOnPasteEvent>> events) {
+      _func([&]() {
+              size_t __size = events->size();
+              std::vector<AixInputWrapperOnPasteEvent> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = events->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/aix/Func_void_std__vector_AixInputWrapperOnPasteEvent__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx(const std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)> _func;
+  };
+
+} // namespace margelo::nitro::aix

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

@@ -56,6 +56,15 @@ namespace margelo::nitro::aix {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JAixStickToKeyboard> /* stickToKeyboard */)>("setStickToKeyboard");
     method(_javaPart, stickToKeyboard.has_value() ? JAixStickToKeyboard::fromCpp(stickToKeyboard.value()) : nullptr);
   }
+  std::optional<bool> JHybridAixComposerSpec::getFixInput() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getFixInput");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridAixComposerSpec::setFixInput(std::optional<bool> fixInput) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* fixInput */)>("setFixInput");
+    method(_javaPart, fixInput.has_value() ? jni::JBoolean::valueOf(fixInput.value()) : nullptr);
+  }
 
   // Methods
   

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

@@ -52,6 +52,8 @@ namespace margelo::nitro::aix {
     // Properties
     std::optional<AixStickToKeyboard> getStickToKeyboard() override;
     void setStickToKeyboard(const std::optional<AixStickToKeyboard>& stickToKeyboard) override;
+    std::optional<bool> getFixInput() override;
+    void setFixInput(std::optional<bool> fixInput) override;
 
   public:
     // Methods

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

@@ -0,0 +1,72 @@
+///
+/// JHybridAixDropzoneSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAixDropzoneSpec.hpp"
+
+// Forward declaration of `AixInputWrapperOnPasteEvent` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixInputWrapperOnPasteEvent; }
+
+#include "AixInputWrapperOnPasteEvent.hpp"
+#include <vector>
+#include <functional>
+#include <optional>
+#include "JFunc_void_std__vector_AixInputWrapperOnPasteEvent_.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JAixInputWrapperOnPasteEvent.hpp"
+#include <string>
+
+namespace margelo::nitro::aix {
+
+  jni::local_ref<JHybridAixDropzoneSpec::jhybriddata> JHybridAixDropzoneSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridAixDropzoneSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridAixDropzoneSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridAixDropzoneSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridAixDropzoneSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridAixDropzoneSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>> JHybridAixDropzoneSpec::getOnDrop() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__vector_AixInputWrapperOnPasteEvent_::javaobject>()>("getOnDrop_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)> {
+      if (__result->isInstanceOf(JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__vector_AixInputWrapperOnPasteEvent_, void(std::vector<AixInputWrapperOnPasteEvent>)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridAixDropzoneSpec::setOnDrop(const std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>& onDrop) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__vector_AixInputWrapperOnPasteEvent_::javaobject> /* onDrop */)>("setOnDrop_cxx");
+    method(_javaPart, onDrop.has_value() ? JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx::fromCpp(onDrop.value()) : nullptr);
+  }
+
+  // Methods
+  
+
+} // namespace margelo::nitro::aix

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

@@ -0,0 +1,66 @@
+///
+/// HybridAixDropzoneSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridAixDropzoneSpec.hpp"
+
+
+
+
+namespace margelo::nitro::aix {
+
+  using namespace facebook;
+
+  class JHybridAixDropzoneSpec: public jni::HybridClass<JHybridAixDropzoneSpec, JHybridObject>,
+                                public virtual HybridAixDropzoneSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/aix/HybridAixDropzoneSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridAixDropzoneSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridAixDropzoneSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridAixDropzoneSpec() 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<JHybridAixDropzoneSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>> getOnDrop() override;
+    void setOnDrop(const std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>& onDrop) override;
+
+  public:
+    // Methods
+    
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridAixDropzoneSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::aix

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

@@ -0,0 +1,144 @@
+///
+/// JHybridAixInputWrapperSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAixInputWrapperSpec.hpp"
+
+// Forward declaration of `AixInputWrapperOnPasteEvent` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixInputWrapperOnPasteEvent; }
+
+#include <string>
+#include <vector>
+#include <optional>
+#include "AixInputWrapperOnPasteEvent.hpp"
+#include <functional>
+#include "JFunc_void_std__vector_AixInputWrapperOnPasteEvent_.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JAixInputWrapperOnPasteEvent.hpp"
+
+namespace margelo::nitro::aix {
+
+  jni::local_ref<JHybridAixInputWrapperSpec::jhybriddata> JHybridAixInputWrapperSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridAixInputWrapperSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridAixInputWrapperSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridAixInputWrapperSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridAixInputWrapperSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridAixInputWrapperSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::optional<std::vector<std::string>> JHybridAixInputWrapperSpec::getPasteConfiguration() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>("getPasteConfiguration");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() {
+      size_t __size = __result->size();
+      std::vector<std::string> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toStdString());
+      }
+      return __vector;
+    }()) : std::nullopt;
+  }
+  void JHybridAixInputWrapperSpec::setPasteConfiguration(const std::optional<std::vector<std::string>>& pasteConfiguration) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<jni::JString>> /* pasteConfiguration */)>("setPasteConfiguration");
+    method(_javaPart, pasteConfiguration.has_value() ? [&]() {
+      size_t __size = pasteConfiguration.value().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 = pasteConfiguration.value()[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }() : nullptr);
+  }
+  std::optional<std::vector<std::string>> JHybridAixInputWrapperSpec::getEditMenuDefaultActions() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>("getEditMenuDefaultActions");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() {
+      size_t __size = __result->size();
+      std::vector<std::string> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toStdString());
+      }
+      return __vector;
+    }()) : std::nullopt;
+  }
+  void JHybridAixInputWrapperSpec::setEditMenuDefaultActions(const std::optional<std::vector<std::string>>& editMenuDefaultActions) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<jni::JString>> /* editMenuDefaultActions */)>("setEditMenuDefaultActions");
+    method(_javaPart, editMenuDefaultActions.has_value() ? [&]() {
+      size_t __size = editMenuDefaultActions.value().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 = editMenuDefaultActions.value()[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }() : nullptr);
+  }
+  std::optional<double> JHybridAixInputWrapperSpec::getMaxLines() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxLines");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridAixInputWrapperSpec::setMaxLines(std::optional<double> maxLines) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxLines */)>("setMaxLines");
+    method(_javaPart, maxLines.has_value() ? jni::JDouble::valueOf(maxLines.value()) : nullptr);
+  }
+  std::optional<double> JHybridAixInputWrapperSpec::getMaxChars() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaxChars");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridAixInputWrapperSpec::setMaxChars(std::optional<double> maxChars) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maxChars */)>("setMaxChars");
+    method(_javaPart, maxChars.has_value() ? jni::JDouble::valueOf(maxChars.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>> JHybridAixInputWrapperSpec::getOnPaste() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__vector_AixInputWrapperOnPasteEvent_::javaobject>()>("getOnPaste_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)> {
+      if (__result->isInstanceOf(JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__vector_AixInputWrapperOnPasteEvent_, void(std::vector<AixInputWrapperOnPasteEvent>)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridAixInputWrapperSpec::setOnPaste(const std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>& onPaste) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__vector_AixInputWrapperOnPasteEvent_::javaobject> /* onPaste */)>("setOnPaste_cxx");
+    method(_javaPart, onPaste.has_value() ? JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx::fromCpp(onPaste.value()) : nullptr);
+  }
+
+  // Methods
+  
+
+} // namespace margelo::nitro::aix

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

@@ -0,0 +1,74 @@
+///
+/// HybridAixInputWrapperSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridAixInputWrapperSpec.hpp"
+
+
+
+
+namespace margelo::nitro::aix {
+
+  using namespace facebook;
+
+  class JHybridAixInputWrapperSpec: public jni::HybridClass<JHybridAixInputWrapperSpec, JHybridObject>,
+                                    public virtual HybridAixInputWrapperSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/aix/HybridAixInputWrapperSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridAixInputWrapperSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridAixInputWrapperSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridAixInputWrapperSpec() 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<JHybridAixInputWrapperSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<std::vector<std::string>> getPasteConfiguration() override;
+    void setPasteConfiguration(const std::optional<std::vector<std::string>>& pasteConfiguration) override;
+    std::optional<std::vector<std::string>> getEditMenuDefaultActions() override;
+    void setEditMenuDefaultActions(const std::optional<std::vector<std::string>>& editMenuDefaultActions) override;
+    std::optional<double> getMaxLines() override;
+    void setMaxLines(std::optional<double> maxLines) override;
+    std::optional<double> getMaxChars() override;
+    void setMaxChars(std::optional<double> maxChars) override;
+    std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>> getOnPaste() override;
+    void setOnPaste(const std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>& onPaste) override;
+
+  public:
+    // Methods
+    
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridAixInputWrapperSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::aix

package/nitrogen/generated/android/c++/views/JHybridAixComposerStateUpdater.cpp

@@ -40,6 +40,10 @@ void JHybridAixComposerStateUpdater::updateViewProps(jni::alias_ref<jni::JClass>
     view->setStickToKeyboard(props.stickToKeyboard.value);
     // TODO: Set isDirty = false
   }
+  if (props.fixInput.isDirty) {
+    view->setFixInput(props.fixInput.value);
+    // TODO: Set isDirty = false
+  }
 
   // Update hybridRef if it changed
   if (props.hybridRef.isDirty) {

package/nitrogen/generated/android/c++/views/JHybridAixDropzoneStateUpdater.cpp

@@ -0,0 +1,56 @@
+///
+/// JHybridAixDropzoneStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAixDropzoneStateUpdater.hpp"
+#include "views/HybridAixDropzoneComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::aix::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridAixDropzoneState>;
+
+void JHybridAixDropzoneStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridAixDropzoneSpec::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  JHybridAixDropzoneSpec* view = javaView->cthis();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::dynamic_pointer_cast<const ConcreteStateData>(state);
+  const HybridAixDropzoneState& data = concreteState->getData();
+  const std::optional<HybridAixDropzoneProps>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridAixDropzoneState's data doesn't contain any props!");
+  }
+  const HybridAixDropzoneProps& props = maybeProps.value();
+  if (props.onDrop.isDirty) {
+    view->setOnDrop(props.onDrop.value);
+    // TODO: Set isDirty = false
+  }
+
+  // Update hybridRef if it changed
+  if (props.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      std::shared_ptr<JHybridAixDropzoneSpec> shared = javaView->cthis()->shared_cast<JHybridAixDropzoneSpec>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace margelo::nitro::aix::views

package/nitrogen/generated/android/c++/views/JHybridAixDropzoneStateUpdater.hpp

@@ -0,0 +1,49 @@
+///
+/// JHybridAixDropzoneStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error Aix was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridAixDropzoneSpec.hpp"
+#include "views/HybridAixDropzoneComponent.hpp"
+
+namespace margelo::nitro::aix::views {
+
+using namespace facebook;
+
+class JHybridAixDropzoneStateUpdater: public jni::JavaClass<JHybridAixDropzoneStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/aix/views/HybridAixDropzoneStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridAixDropzoneSpec::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridAixDropzoneStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridAixDropzoneComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::aix::views