aix 0.6.0 → 0.6.1

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

@@ -14,6 +14,8 @@ namespace margelo::nitro::aix { struct AixAdditionalContentInsetsProp; }
 namespace margelo::nitro::aix { struct AixAdditionalContentInsets; }
 // Forward declaration of `AixContentInsets` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixContentInsets; }
+// Forward declaration of `AixInputWrapperOnPasteEvent` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixInputWrapperOnPasteEvent; }
 // Forward declaration of `AixScrollIndicatorInsetValue` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixScrollIndicatorInsetValue; }
 // Forward declaration of `AixScrollIndicatorInsets` to properly resolve imports.
@@ -28,6 +30,10 @@ namespace margelo::nitro::aix { struct AixStickToKeyboard; }
 namespace margelo::nitro::aix { class HybridAixCellViewSpec; }
 // Forward declaration of `HybridAixComposerSpec` to properly resolve imports.
 namespace margelo::nitro::aix { class HybridAixComposerSpec; }
+// Forward declaration of `HybridAixDropzoneSpec` to properly resolve imports.
+namespace margelo::nitro::aix { class HybridAixDropzoneSpec; }
+// Forward declaration of `HybridAixInputWrapperSpec` to properly resolve imports.
+namespace margelo::nitro::aix { class HybridAixInputWrapperSpec; }
 // Forward declaration of `HybridAixSpec` to properly resolve imports.
 namespace margelo::nitro::aix { class HybridAixSpec; }
 
@@ -36,6 +42,10 @@ namespace margelo::nitro::aix { class HybridAixSpec; }
 namespace Aix { class HybridAixCellViewSpec_cxx; }
 // Forward declaration of `HybridAixComposerSpec_cxx` to properly resolve imports.
 namespace Aix { class HybridAixComposerSpec_cxx; }
+// Forward declaration of `HybridAixDropzoneSpec_cxx` to properly resolve imports.
+namespace Aix { class HybridAixDropzoneSpec_cxx; }
+// Forward declaration of `HybridAixInputWrapperSpec_cxx` to properly resolve imports.
+namespace Aix { class HybridAixInputWrapperSpec_cxx; }
 // Forward declaration of `HybridAixSpec_cxx` to properly resolve imports.
 namespace Aix { class HybridAixSpec_cxx; }
 
@@ -43,6 +53,7 @@ namespace Aix { class HybridAixSpec_cxx; }
 #include "AixAdditionalContentInsets.hpp"
 #include "AixAdditionalContentInsetsProp.hpp"
 #include "AixContentInsets.hpp"
+#include "AixInputWrapperOnPasteEvent.hpp"
 #include "AixScrollIndicatorInsetValue.hpp"
 #include "AixScrollIndicatorInsets.hpp"
 #include "AixScrollOnFooterSizeUpdate.hpp"
@@ -50,6 +61,8 @@ namespace Aix { class HybridAixSpec_cxx; }
 #include "AixStickToKeyboardOffset.hpp"
 #include "HybridAixCellViewSpec.hpp"
 #include "HybridAixComposerSpec.hpp"
+#include "HybridAixDropzoneSpec.hpp"
+#include "HybridAixInputWrapperSpec.hpp"
 #include "HybridAixSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <exception>
@@ -57,6 +70,7 @@ namespace Aix { class HybridAixSpec_cxx; }
 #include <memory>
 #include <optional>
 #include <string>
+#include <vector>
 
 /**
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
@@ -332,5 +346,103 @@ namespace margelo::nitro::aix::bridge::swift {
   // pragma MARK: std::weak_ptr<HybridAixComposerSpec>
   using std__weak_ptr_HybridAixComposerSpec_ = std::weak_ptr<HybridAixComposerSpec>;
   inline std__weak_ptr_HybridAixComposerSpec_ weakify_std__shared_ptr_HybridAixComposerSpec_(const std::shared_ptr<HybridAixComposerSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::vector<std::string>
+  /**
+   * Specialized version of `std::vector<std::string>`.
+   */
+  using std__vector_std__string_ = std::vector<std::string>;
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
+    std::vector<std::string> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<std::string>>
+  /**
+   * Specialized version of `std::optional<std::vector<std::string>>`.
+   */
+  using std__optional_std__vector_std__string__ = std::optional<std::vector<std::string>>;
+  inline std::optional<std::vector<std::string>> create_std__optional_std__vector_std__string__(const std::vector<std::string>& value) noexcept {
+    return std::optional<std::vector<std::string>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<std::string> get_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<AixInputWrapperOnPasteEvent>
+  /**
+   * Specialized version of `std::vector<AixInputWrapperOnPasteEvent>`.
+   */
+  using std__vector_AixInputWrapperOnPasteEvent_ = std::vector<AixInputWrapperOnPasteEvent>;
+  inline std::vector<AixInputWrapperOnPasteEvent> create_std__vector_AixInputWrapperOnPasteEvent_(size_t size) noexcept {
+    std::vector<AixInputWrapperOnPasteEvent> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<AixInputWrapperOnPasteEvent>&)>`.
+   */
+  using Func_void_std__vector_AixInputWrapperOnPasteEvent_ = std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& / * events * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_AixInputWrapperOnPasteEvent__Wrapper final {
+  public:
+    explicit Func_void_std__vector_AixInputWrapperOnPasteEvent__Wrapper(std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>&& func): _function(std::make_unique<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>(std::move(func))) {}
+    inline void call(std::vector<AixInputWrapperOnPasteEvent> events) const noexcept {
+      _function->operator()(events);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_AixInputWrapperOnPasteEvent_ create_Func_void_std__vector_AixInputWrapperOnPasteEvent_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_AixInputWrapperOnPasteEvent__Wrapper wrap_Func_void_std__vector_AixInputWrapperOnPasteEvent_(Func_void_std__vector_AixInputWrapperOnPasteEvent_ value) noexcept {
+    return Func_void_std__vector_AixInputWrapperOnPasteEvent__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& / * events * /)>>`.
+   */
+  using std__optional_std__function_void_const_std__vector_AixInputWrapperOnPasteEvent______events______ = std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>;
+  inline std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>> create_std__optional_std__function_void_const_std__vector_AixInputWrapperOnPasteEvent______events______(const std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>& value) noexcept {
+    return std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_std__vector_AixInputWrapperOnPasteEvent______events______(const std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)> get_std__optional_std__function_void_const_std__vector_AixInputWrapperOnPasteEvent______events______(const std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridAixInputWrapperSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridAixInputWrapperSpec>`.
+   */
+  using std__shared_ptr_HybridAixInputWrapperSpec_ = std::shared_ptr<HybridAixInputWrapperSpec>;
+  std::shared_ptr<HybridAixInputWrapperSpec> create_std__shared_ptr_HybridAixInputWrapperSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridAixInputWrapperSpec_(std__shared_ptr_HybridAixInputWrapperSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridAixInputWrapperSpec>
+  using std__weak_ptr_HybridAixInputWrapperSpec_ = std::weak_ptr<HybridAixInputWrapperSpec>;
+  inline std__weak_ptr_HybridAixInputWrapperSpec_ weakify_std__shared_ptr_HybridAixInputWrapperSpec_(const std::shared_ptr<HybridAixInputWrapperSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: std::shared_ptr<HybridAixDropzoneSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridAixDropzoneSpec>`.
+   */
+  using std__shared_ptr_HybridAixDropzoneSpec_ = std::shared_ptr<HybridAixDropzoneSpec>;
+  std::shared_ptr<HybridAixDropzoneSpec> create_std__shared_ptr_HybridAixDropzoneSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridAixDropzoneSpec_(std__shared_ptr_HybridAixDropzoneSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridAixDropzoneSpec>
+  using std__weak_ptr_HybridAixDropzoneSpec_ = std::weak_ptr<HybridAixDropzoneSpec>;
+  inline std__weak_ptr_HybridAixDropzoneSpec_ weakify_std__shared_ptr_HybridAixDropzoneSpec_(const std::shared_ptr<HybridAixDropzoneSpec>& strong) noexcept { return strong; }
 
 } // namespace margelo::nitro::aix::bridge::swift

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

@@ -14,6 +14,8 @@ namespace margelo::nitro::aix { struct AixAdditionalContentInsetsProp; }
 namespace margelo::nitro::aix { struct AixAdditionalContentInsets; }
 // Forward declaration of `AixContentInsets` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixContentInsets; }
+// Forward declaration of `AixInputWrapperOnPasteEvent` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixInputWrapperOnPasteEvent; }
 // Forward declaration of `AixScrollIndicatorInsetValue` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixScrollIndicatorInsetValue; }
 // Forward declaration of `AixScrollIndicatorInsets` to properly resolve imports.
@@ -28,6 +30,10 @@ namespace margelo::nitro::aix { struct AixStickToKeyboard; }
 namespace margelo::nitro::aix { class HybridAixCellViewSpec; }
 // Forward declaration of `HybridAixComposerSpec` to properly resolve imports.
 namespace margelo::nitro::aix { class HybridAixComposerSpec; }
+// Forward declaration of `HybridAixDropzoneSpec` to properly resolve imports.
+namespace margelo::nitro::aix { class HybridAixDropzoneSpec; }
+// Forward declaration of `HybridAixInputWrapperSpec` to properly resolve imports.
+namespace margelo::nitro::aix { class HybridAixInputWrapperSpec; }
 // Forward declaration of `HybridAixSpec` to properly resolve imports.
 namespace margelo::nitro::aix { class HybridAixSpec; }
 
@@ -35,6 +41,7 @@ namespace margelo::nitro::aix { class HybridAixSpec; }
 #include "AixAdditionalContentInsets.hpp"
 #include "AixAdditionalContentInsetsProp.hpp"
 #include "AixContentInsets.hpp"
+#include "AixInputWrapperOnPasteEvent.hpp"
 #include "AixScrollIndicatorInsetValue.hpp"
 #include "AixScrollIndicatorInsets.hpp"
 #include "AixScrollOnFooterSizeUpdate.hpp"
@@ -42,6 +49,8 @@ namespace margelo::nitro::aix { class HybridAixSpec; }
 #include "AixStickToKeyboardOffset.hpp"
 #include "HybridAixCellViewSpec.hpp"
 #include "HybridAixComposerSpec.hpp"
+#include "HybridAixDropzoneSpec.hpp"
+#include "HybridAixInputWrapperSpec.hpp"
 #include "HybridAixSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <exception>
@@ -49,6 +58,7 @@ namespace margelo::nitro::aix { class HybridAixSpec; }
 #include <memory>
 #include <optional>
 #include <string>
+#include <vector>
 
 // C++ helpers for Swift
 #include "Aix-Swift-Cxx-Bridge.hpp"
@@ -64,6 +74,10 @@ namespace margelo::nitro::aix { class HybridAixSpec; }
 namespace Aix { class HybridAixCellViewSpec_cxx; }
 // Forward declaration of `HybridAixComposerSpec_cxx` to properly resolve imports.
 namespace Aix { class HybridAixComposerSpec_cxx; }
+// Forward declaration of `HybridAixDropzoneSpec_cxx` to properly resolve imports.
+namespace Aix { class HybridAixDropzoneSpec_cxx; }
+// Forward declaration of `HybridAixInputWrapperSpec_cxx` to properly resolve imports.
+namespace Aix { class HybridAixInputWrapperSpec_cxx; }
 // Forward declaration of `HybridAixSpec_cxx` to properly resolve imports.
 namespace Aix { class HybridAixSpec_cxx; }
 

package/nitrogen/generated/ios/AixAutolinking.mm

@@ -13,6 +13,8 @@
 #include "HybridAixSpecSwift.hpp"
 #include "HybridAixCellViewSpecSwift.hpp"
 #include "HybridAixComposerSpecSwift.hpp"
+#include "HybridAixInputWrapperSpecSwift.hpp"
+#include "HybridAixDropzoneSpecSwift.hpp"
 
 @interface AixAutolinking : NSObject
 @end
@@ -44,6 +46,20 @@
       return hybridObject;
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AixInputWrapper",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridAixInputWrapperSpec> hybridObject = Aix::AixAutolinking::createAixInputWrapper();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AixDropzone",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridAixDropzoneSpec> hybridObject = Aix::AixAutolinking::createAixDropzone();
+      return hybridObject;
+    }
+  );
 }
 
 @end

package/nitrogen/generated/ios/AixAutolinking.swift

@@ -52,4 +52,34 @@ public final class AixAutolinking {
       return __cxxWrapped.getCxxPart()
     }()
   }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridAixInputWrapperSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridAixInputWrapperSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridAixInputWrapper`).
+   */
+  public static func createAixInputWrapper() -> bridge.std__shared_ptr_HybridAixInputWrapperSpec_ {
+    let hybridObject = HybridAixInputWrapper()
+    return { () -> bridge.std__shared_ptr_HybridAixInputWrapperSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridAixDropzoneSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridAixDropzoneSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridAixDropzone`).
+   */
+  public static func createAixDropzone() -> bridge.std__shared_ptr_HybridAixDropzoneSpec_ {
+    let hybridObject = HybridAixDropzone()
+    return { () -> bridge.std__shared_ptr_HybridAixDropzoneSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
 }

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

@@ -68,6 +68,13 @@ namespace margelo::nitro::aix {
     inline void setStickToKeyboard(const std::optional<AixStickToKeyboard>& stickToKeyboard) noexcept override {
       _swiftPart.setStickToKeyboard(stickToKeyboard);
     }
+    inline std::optional<bool> getFixInput() noexcept override {
+      auto __result = _swiftPart.getFixInput();
+      return __result;
+    }
+    inline void setFixInput(std::optional<bool> fixInput) noexcept override {
+      _swiftPart.setFixInput(fixInput);
+    }
 
   public:
     // Methods

package/nitrogen/generated/ios/c++/HybridAixDropzoneSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridAixDropzoneSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAixDropzoneSpecSwift.hpp"
+
+namespace margelo::nitro::aix {
+} // namespace margelo::nitro::aix

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

@@ -0,0 +1,80 @@
+///
+/// HybridAixDropzoneSpecSwift.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 "HybridAixDropzoneSpec.hpp"
+
+// Forward declaration of `HybridAixDropzoneSpec_cxx` to properly resolve imports.
+namespace Aix { class HybridAixDropzoneSpec_cxx; }
+
+// Forward declaration of `AixInputWrapperOnPasteEvent` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixInputWrapperOnPasteEvent; }
+
+#include "AixInputWrapperOnPasteEvent.hpp"
+#include <vector>
+#include <functional>
+#include <optional>
+#include <string>
+
+#include "Aix-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::aix {
+
+  /**
+   * The C++ part of HybridAixDropzoneSpec_cxx.swift.
+   *
+   * HybridAixDropzoneSpecSwift (C++) accesses HybridAixDropzoneSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridAixDropzoneSpec_cxx can directly inherit from the C++ class HybridAixDropzoneSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridAixDropzoneSpecSwift: public virtual HybridAixDropzoneSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridAixDropzoneSpecSwift(const Aix::HybridAixDropzoneSpec_cxx& swiftPart):
+      HybridObject(HybridAixDropzoneSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline Aix::HybridAixDropzoneSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>> getOnDrop() noexcept override {
+      auto __result = _swiftPart.getOnDrop();
+      return __result;
+    }
+    inline void setOnDrop(const std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>& onDrop) noexcept override {
+      _swiftPart.setOnDrop(onDrop);
+    }
+
+  public:
+    // Methods
+    
+
+  private:
+    Aix::HybridAixDropzoneSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::aix

package/nitrogen/generated/ios/c++/HybridAixInputWrapperSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridAixInputWrapperSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAixInputWrapperSpecSwift.hpp"
+
+namespace margelo::nitro::aix {
+} // namespace margelo::nitro::aix

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

@@ -0,0 +1,108 @@
+///
+/// HybridAixInputWrapperSpecSwift.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 "HybridAixInputWrapperSpec.hpp"
+
+// Forward declaration of `HybridAixInputWrapperSpec_cxx` to properly resolve imports.
+namespace Aix { class HybridAixInputWrapperSpec_cxx; }
+
+// 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 "Aix-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::aix {
+
+  /**
+   * The C++ part of HybridAixInputWrapperSpec_cxx.swift.
+   *
+   * HybridAixInputWrapperSpecSwift (C++) accesses HybridAixInputWrapperSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridAixInputWrapperSpec_cxx can directly inherit from the C++ class HybridAixInputWrapperSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridAixInputWrapperSpecSwift: public virtual HybridAixInputWrapperSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridAixInputWrapperSpecSwift(const Aix::HybridAixInputWrapperSpec_cxx& swiftPart):
+      HybridObject(HybridAixInputWrapperSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline Aix::HybridAixInputWrapperSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::optional<std::vector<std::string>> getPasteConfiguration() noexcept override {
+      auto __result = _swiftPart.getPasteConfiguration();
+      return __result;
+    }
+    inline void setPasteConfiguration(const std::optional<std::vector<std::string>>& pasteConfiguration) noexcept override {
+      _swiftPart.setPasteConfiguration(pasteConfiguration);
+    }
+    inline std::optional<std::vector<std::string>> getEditMenuDefaultActions() noexcept override {
+      auto __result = _swiftPart.getEditMenuDefaultActions();
+      return __result;
+    }
+    inline void setEditMenuDefaultActions(const std::optional<std::vector<std::string>>& editMenuDefaultActions) noexcept override {
+      _swiftPart.setEditMenuDefaultActions(editMenuDefaultActions);
+    }
+    inline std::optional<double> getMaxLines() noexcept override {
+      auto __result = _swiftPart.getMaxLines();
+      return __result;
+    }
+    inline void setMaxLines(std::optional<double> maxLines) noexcept override {
+      _swiftPart.setMaxLines(maxLines);
+    }
+    inline std::optional<double> getMaxChars() noexcept override {
+      auto __result = _swiftPart.getMaxChars();
+      return __result;
+    }
+    inline void setMaxChars(std::optional<double> maxChars) noexcept override {
+      _swiftPart.setMaxChars(maxChars);
+    }
+    inline std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>> getOnPaste() noexcept override {
+      auto __result = _swiftPart.getOnPaste();
+      return __result;
+    }
+    inline void setOnPaste(const std::optional<std::function<void(const std::vector<AixInputWrapperOnPasteEvent>& /* events */)>>& onPaste) noexcept override {
+      _swiftPart.setOnPaste(onPaste);
+    }
+
+  public:
+    // Methods
+    
+
+  private:
+    Aix::HybridAixInputWrapperSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::aix

package/nitrogen/generated/ios/c++/views/HybridAixComposerComponent.mm

@@ -76,6 +76,11 @@ using namespace margelo::nitro::aix::views;
     swiftPart.setStickToKeyboard(newViewProps.stickToKeyboard.value);
     newViewProps.stickToKeyboard.isDirty = false;
   }
+  // fixInput: optional
+  if (newViewProps.fixInput.isDirty) {
+    swiftPart.setFixInput(newViewProps.fixInput.value);
+    newViewProps.fixInput.isDirty = false;
+  }
 
   swiftPart.afterUpdate();
 

package/nitrogen/generated/ios/c++/views/HybridAixDropzoneComponent.mm

@@ -0,0 +1,96 @@
+///
+/// HybridAixDropzoneComponent.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#import "HybridAixDropzoneComponent.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "HybridAixDropzoneSpecSwift.hpp"
+#import "Aix-Swift-Cxx-Umbrella.hpp"
+
+using namespace facebook;
+using namespace margelo::nitro::aix;
+using namespace margelo::nitro::aix::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "AixDropzone" HybridView.
+ */
+@interface HybridAixDropzoneComponent: RCTViewComponentView
+@end
+
+@implementation HybridAixDropzoneComponent {
+  std::shared_ptr<HybridAixDropzoneSpecSwift> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridAixDropzoneComponent class]];
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<HybridAixDropzoneComponentDescriptor>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<HybridAixDropzoneSpec> hybridView = Aix::AixAutolinking::createAixDropzone();
+    _hybridView = std::dynamic_pointer_cast<HybridAixDropzoneSpecSwift>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  Aix::HybridAixDropzoneSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<HybridAixDropzoneProps const>(props);
+  auto& newViewProps = const_cast<HybridAixDropzoneProps&>(newViewPropsConst);
+  Aix::HybridAixDropzoneSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  // onDrop: optional
+  if (newViewProps.onDrop.isDirty) {
+    swiftPart.setOnDrop(newViewProps.onDrop.value);
+    newViewProps.onDrop.isDirty = false;
+  }
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end