aix 0.2.0 → 0.3.1

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

@@ -0,0 +1,63 @@
+///
+/// JAixStickToKeyboard.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 "AixStickToKeyboard.hpp"
+
+#include "AixStickToKeyboardOffset.hpp"
+#include "JAixStickToKeyboardOffset.hpp"
+#include <optional>
+
+namespace margelo::nitro::aix {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AixStickToKeyboard" and the the Kotlin data class "AixStickToKeyboard".
+   */
+  struct JAixStickToKeyboard final: public jni::JavaClass<JAixStickToKeyboard> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/aix/AixStickToKeyboard;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AixStickToKeyboard by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AixStickToKeyboard toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldEnabled = clazz->getField<jboolean>("enabled");
+      jboolean enabled = this->getFieldValue(fieldEnabled);
+      static const auto fieldOffset = clazz->getField<JAixStickToKeyboardOffset>("offset");
+      jni::local_ref<JAixStickToKeyboardOffset> offset = this->getFieldValue(fieldOffset);
+      return AixStickToKeyboard(
+        static_cast<bool>(enabled),
+        offset != nullptr ? std::make_optional(offset->toCpp()) : 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<JAixStickToKeyboard::javaobject> fromCpp(const AixStickToKeyboard& value) {
+      using JSignature = JAixStickToKeyboard(jboolean, jni::alias_ref<JAixStickToKeyboardOffset>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.enabled,
+        value.offset.has_value() ? JAixStickToKeyboardOffset::fromCpp(value.offset.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::aix

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

@@ -0,0 +1,61 @@
+///
+/// JAixStickToKeyboardOffset.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 "AixStickToKeyboardOffset.hpp"
+
+
+
+namespace margelo::nitro::aix {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AixStickToKeyboardOffset" and the the Kotlin data class "AixStickToKeyboardOffset".
+   */
+  struct JAixStickToKeyboardOffset final: public jni::JavaClass<JAixStickToKeyboardOffset> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/aix/AixStickToKeyboardOffset;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AixStickToKeyboardOffset by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AixStickToKeyboardOffset toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldWhenKeyboardOpen = clazz->getField<double>("whenKeyboardOpen");
+      double whenKeyboardOpen = this->getFieldValue(fieldWhenKeyboardOpen);
+      static const auto fieldWhenKeyboardClosed = clazz->getField<double>("whenKeyboardClosed");
+      double whenKeyboardClosed = this->getFieldValue(fieldWhenKeyboardClosed);
+      return AixStickToKeyboardOffset(
+        whenKeyboardOpen,
+        whenKeyboardClosed
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JAixStickToKeyboardOffset::javaobject> fromCpp(const AixStickToKeyboardOffset& value) {
+      using JSignature = JAixStickToKeyboardOffset(double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.whenKeyboardOpen,
+        value.whenKeyboardClosed
+      );
+    }
+  };
+
+} // namespace margelo::nitro::aix

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_bool.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 <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::aix {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(isNearEnd: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/aix/Func_void_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
+     */
+    void invoke(bool isNearEnd) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* isNearEnd */)>("invoke");
+      method(self(), isNearEnd);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
+  public:
+    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* isNearEnd */)>& func) {
+      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean isNearEnd) {
+      _func(static_cast<bool>(isNearEnd));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* isNearEnd */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/aix/Func_void_bool_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_cxx(const std::function<void(bool /* isNearEnd */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* isNearEnd */)> _func;
+  };
+
+} // namespace margelo::nitro::aix

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

@@ -7,9 +7,16 @@
 
 #include "JHybridAixComposerSpec.hpp"
 
+// Forward declaration of `AixStickToKeyboard` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixStickToKeyboard; }
+// Forward declaration of `AixStickToKeyboardOffset` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixStickToKeyboardOffset; }
 
-
-
+#include "AixStickToKeyboard.hpp"
+#include <optional>
+#include "JAixStickToKeyboard.hpp"
+#include "AixStickToKeyboardOffset.hpp"
+#include "JAixStickToKeyboardOffset.hpp"
 
 namespace margelo::nitro::aix {
 
@@ -40,7 +47,15 @@ namespace margelo::nitro::aix {
   }
 
   // Properties
-  
+  std::optional<AixStickToKeyboard> JHybridAixComposerSpec::getStickToKeyboard() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JAixStickToKeyboard>()>("getStickToKeyboard");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridAixComposerSpec::setStickToKeyboard(const std::optional<AixStickToKeyboard>& stickToKeyboard) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JAixStickToKeyboard> /* stickToKeyboard */)>("setStickToKeyboard");
+    method(_javaPart, stickToKeyboard.has_value() ? JAixStickToKeyboard::fromCpp(stickToKeyboard.value()) : nullptr);
+  }
 
   // Methods
   

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

@@ -50,7 +50,8 @@ namespace margelo::nitro::aix {
 
   public:
     // Properties
-    
+    std::optional<AixStickToKeyboard> getStickToKeyboard() override;
+    void setStickToKeyboard(const std::optional<AixStickToKeyboard>& stickToKeyboard) override;
 
   public:
     // Methods

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

@@ -37,6 +37,7 @@ namespace margelo::nitro::aix { struct AixContentInsets; }
 #include "JFunc_void_AixContentInsets.hpp"
 #include <NitroModules/JNICallable.hpp>
 #include "JAixContentInsets.hpp"
+#include "JFunc_void_bool.hpp"
 
 namespace margelo::nitro::aix {
 
@@ -156,6 +157,23 @@ namespace margelo::nitro::aix {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_AixContentInsets::javaobject> /* onWillApplyContentInsets */)>("setOnWillApplyContentInsets_cxx");
     method(_javaPart, onWillApplyContentInsets.has_value() ? JFunc_void_AixContentInsets_cxx::fromCpp(onWillApplyContentInsets.value()) : nullptr);
   }
+  std::optional<std::function<void(bool /* isNearEnd */)>> JHybridAixSpec::getOnScrolledNearEndChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_bool::javaobject>()>("getOnScrolledNearEndChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(bool /* isNearEnd */)> {
+      if (__result->isInstanceOf(JFunc_void_bool_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_bool_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_bool, void(bool)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridAixSpec::setOnScrolledNearEndChange(const std::optional<std::function<void(bool /* isNearEnd */)>>& onScrolledNearEndChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* onScrolledNearEndChange */)>("setOnScrolledNearEndChange_cxx");
+    method(_javaPart, onScrolledNearEndChange.has_value() ? JFunc_void_bool_cxx::fromCpp(onScrolledNearEndChange.value()) : nullptr);
+  }
 
   // Methods
   void JHybridAixSpec::scrollToEnd(std::optional<bool> animated) {

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

@@ -68,6 +68,8 @@ namespace margelo::nitro::aix {
     void setShouldApplyContentInsets(std::optional<bool> shouldApplyContentInsets) override;
     std::optional<std::function<void(const AixContentInsets& /* insets */)>> getOnWillApplyContentInsets() override;
     void setOnWillApplyContentInsets(const std::optional<std::function<void(const AixContentInsets& /* insets */)>>& onWillApplyContentInsets) override;
+    std::optional<std::function<void(bool /* isNearEnd */)>> getOnScrolledNearEndChange() override;
+    void setOnScrolledNearEndChange(const std::optional<std::function<void(bool /* isNearEnd */)>>& onScrolledNearEndChange) override;
 
   public:
     // Methods

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

@@ -36,7 +36,10 @@ void JHybridAixComposerStateUpdater::updateViewProps(jni::alias_ref<jni::JClass>
     throw std::runtime_error("HybridAixComposerState's data doesn't contain any props!");
   }
   const HybridAixComposerProps& props = maybeProps.value();
-  
+  if (props.stickToKeyboard.isDirty) {
+    view->setStickToKeyboard(props.stickToKeyboard.value);
+    // TODO: Set isDirty = false
+  }
 
   // Update hybridRef if it changed
   if (props.hybridRef.isDirty) {

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

@@ -72,6 +72,10 @@ void JHybridAixStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* clas
     view->setOnWillApplyContentInsets(props.onWillApplyContentInsets.value);
     // TODO: Set isDirty = false
   }
+  if (props.onScrolledNearEndChange.isDirty) {
+    view->setOnScrolledNearEndChange(props.onScrolledNearEndChange.value);
+    // TODO: Set isDirty = false
+  }
 
   // Update hybridRef if it changed
   if (props.hybridRef.isDirty) {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/aix/AixStickToKeyboard.kt

@@ -0,0 +1,41 @@
+///
+/// AixStickToKeyboard.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.aix
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "AixStickToKeyboard".
+ */
+@DoNotStrip
+@Keep
+data class AixStickToKeyboard(
+  @DoNotStrip
+  @Keep
+  val enabled: Boolean,
+  @DoNotStrip
+  @Keep
+  val offset: AixStickToKeyboardOffset?
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(enabled: Boolean, offset: AixStickToKeyboardOffset?): AixStickToKeyboard {
+      return AixStickToKeyboard(enabled, offset)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/aix/AixStickToKeyboardOffset.kt

@@ -0,0 +1,41 @@
+///
+/// AixStickToKeyboardOffset.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.aix
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "AixStickToKeyboardOffset".
+ */
+@DoNotStrip
+@Keep
+data class AixStickToKeyboardOffset(
+  @DoNotStrip
+  @Keep
+  val whenKeyboardOpen: Double,
+  @DoNotStrip
+  @Keep
+  val whenKeyboardClosed: Double
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(whenKeyboardOpen: Double, whenKeyboardClosed: Double): AixStickToKeyboardOffset {
+      return AixStickToKeyboardOffset(whenKeyboardOpen, whenKeyboardClosed)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/aix/Func_void_bool.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_bool.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.aix
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(isNearEnd: boolean) => 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_bool: (Boolean) -> 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(isNearEnd: Boolean): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(isNearEnd: boolean) => 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_bool_cxx: Func_void_bool {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(isNearEnd: Boolean): Unit
+    = invoke_cxx(isNearEnd)
+
+  @FastNative
+  private external fun invoke_cxx(isNearEnd: Boolean): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(isNearEnd: boolean) => void`.
+ * This is implemented in Java/Kotlin, via a `(Boolean) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_bool_java(private val function: (Boolean) -> Unit): Func_void_bool {
+  @DoNotStrip
+  @Keep
+  override fun invoke(isNearEnd: Boolean): Unit {
+    return this.function(isNearEnd)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/aix/HybridAixComposerSpec.kt

@@ -42,7 +42,11 @@ abstract class HybridAixComposerSpec: HybridView() {
   }
 
   // Properties
-  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var stickToKeyboard: AixStickToKeyboard?
 
   // Methods
   

package/nitrogen/generated/android/kotlin/com/margelo/nitro/aix/HybridAixSpec.kt

@@ -103,6 +103,20 @@ abstract class HybridAixSpec: HybridView() {
     set(value) {
       onWillApplyContentInsets = value?.let { it }
     }
+  
+  abstract var onScrolledNearEndChange: ((isNearEnd: Boolean) -> Unit)?
+  
+  private var onScrolledNearEndChange_cxx: Func_void_bool?
+    @Keep
+    @DoNotStrip
+    get() {
+      return onScrolledNearEndChange?.let { Func_void_bool_java(it) }
+    }
+    @Keep
+    @DoNotStrip
+    set(value) {
+      onScrolledNearEndChange = value?.let { it }
+    }
 
   // Methods
   @DoNotStrip

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

@@ -24,6 +24,14 @@ namespace margelo::nitro::aix::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(bool /* isNearEnd */)>
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = Aix::Func_void_bool::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool isNearEnd) mutable -> void {
+      swiftClosure.call(isNearEnd);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridAixSpec>
   std::shared_ptr<HybridAixSpec> create_std__shared_ptr_HybridAixSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     Aix::HybridAixSpec_cxx swiftPart = Aix::HybridAixSpec_cxx::fromUnsafe(swiftUnsafePointer);

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

@@ -20,6 +20,10 @@ namespace margelo::nitro::aix { struct AixScrollIndicatorInsetValue; }
 namespace margelo::nitro::aix { struct AixScrollIndicatorInsets; }
 // Forward declaration of `AixScrollOnFooterSizeUpdate` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixScrollOnFooterSizeUpdate; }
+// Forward declaration of `AixStickToKeyboardOffset` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixStickToKeyboardOffset; }
+// Forward declaration of `AixStickToKeyboard` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixStickToKeyboard; }
 // Forward declaration of `HybridAixCellViewSpec` to properly resolve imports.
 namespace margelo::nitro::aix { class HybridAixCellViewSpec; }
 // Forward declaration of `HybridAixComposerSpec` to properly resolve imports.
@@ -42,6 +46,8 @@ namespace Aix { class HybridAixSpec_cxx; }
 #include "AixScrollIndicatorInsetValue.hpp"
 #include "AixScrollIndicatorInsets.hpp"
 #include "AixScrollOnFooterSizeUpdate.hpp"
+#include "AixStickToKeyboard.hpp"
+#include "AixStickToKeyboardOffset.hpp"
 #include "HybridAixCellViewSpec.hpp"
 #include "HybridAixComposerSpec.hpp"
 #include "HybridAixSpec.hpp"
@@ -215,6 +221,43 @@ namespace margelo::nitro::aix::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::function<void(bool /* isNearEnd */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* isNearEnd */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * isNearEnd * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* isNearEnd */)>&& func): _function(std::make_unique<std::function<void(bool /* isNearEnd */)>>(std::move(func))) {}
+    inline void call(bool isNearEnd) const noexcept {
+      _function->operator()(isNearEnd);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* isNearEnd */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(bool /* isNearEnd */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(bool / * isNearEnd * /)>>`.
+   */
+  using std__optional_std__function_void_bool____isNearEnd______ = std::optional<std::function<void(bool /* isNearEnd */)>>;
+  inline std::optional<std::function<void(bool /* isNearEnd */)>> create_std__optional_std__function_void_bool____isNearEnd______(const std::function<void(bool /* isNearEnd */)>& value) noexcept {
+    return std::optional<std::function<void(bool /* isNearEnd */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_bool____isNearEnd______(const std::optional<std::function<void(bool /* isNearEnd */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(bool /* isNearEnd */)> get_std__optional_std__function_void_bool____isNearEnd______(const std::optional<std::function<void(bool /* isNearEnd */)>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<HybridAixSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridAixSpec>`.
@@ -248,6 +291,36 @@ namespace margelo::nitro::aix::bridge::swift {
   using std__weak_ptr_HybridAixCellViewSpec_ = std::weak_ptr<HybridAixCellViewSpec>;
   inline std__weak_ptr_HybridAixCellViewSpec_ weakify_std__shared_ptr_HybridAixCellViewSpec_(const std::shared_ptr<HybridAixCellViewSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: std::optional<AixStickToKeyboardOffset>
+  /**
+   * Specialized version of `std::optional<AixStickToKeyboardOffset>`.
+   */
+  using std__optional_AixStickToKeyboardOffset_ = std::optional<AixStickToKeyboardOffset>;
+  inline std::optional<AixStickToKeyboardOffset> create_std__optional_AixStickToKeyboardOffset_(const AixStickToKeyboardOffset& value) noexcept {
+    return std::optional<AixStickToKeyboardOffset>(value);
+  }
+  inline bool has_value_std__optional_AixStickToKeyboardOffset_(const std::optional<AixStickToKeyboardOffset>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AixStickToKeyboardOffset get_std__optional_AixStickToKeyboardOffset_(const std::optional<AixStickToKeyboardOffset>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<AixStickToKeyboard>
+  /**
+   * Specialized version of `std::optional<AixStickToKeyboard>`.
+   */
+  using std__optional_AixStickToKeyboard_ = std::optional<AixStickToKeyboard>;
+  inline std::optional<AixStickToKeyboard> create_std__optional_AixStickToKeyboard_(const AixStickToKeyboard& value) noexcept {
+    return std::optional<AixStickToKeyboard>(value);
+  }
+  inline bool has_value_std__optional_AixStickToKeyboard_(const std::optional<AixStickToKeyboard>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AixStickToKeyboard get_std__optional_AixStickToKeyboard_(const std::optional<AixStickToKeyboard>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<HybridAixComposerSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridAixComposerSpec>`.

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

@@ -20,6 +20,10 @@ namespace margelo::nitro::aix { struct AixScrollIndicatorInsetValue; }
 namespace margelo::nitro::aix { struct AixScrollIndicatorInsets; }
 // Forward declaration of `AixScrollOnFooterSizeUpdate` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixScrollOnFooterSizeUpdate; }
+// Forward declaration of `AixStickToKeyboardOffset` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixStickToKeyboardOffset; }
+// Forward declaration of `AixStickToKeyboard` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixStickToKeyboard; }
 // Forward declaration of `HybridAixCellViewSpec` to properly resolve imports.
 namespace margelo::nitro::aix { class HybridAixCellViewSpec; }
 // Forward declaration of `HybridAixComposerSpec` to properly resolve imports.
@@ -34,6 +38,8 @@ namespace margelo::nitro::aix { class HybridAixSpec; }
 #include "AixScrollIndicatorInsetValue.hpp"
 #include "AixScrollIndicatorInsets.hpp"
 #include "AixScrollOnFooterSizeUpdate.hpp"
+#include "AixStickToKeyboard.hpp"
+#include "AixStickToKeyboardOffset.hpp"
 #include "HybridAixCellViewSpec.hpp"
 #include "HybridAixComposerSpec.hpp"
 #include "HybridAixSpec.hpp"