aix 0.1.0 → 0.2.0

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

@@ -0,0 +1,47 @@
+///
+/// AixContentInsets.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 "AixContentInsets".
+ */
+@DoNotStrip
+@Keep
+data class AixContentInsets(
+  @DoNotStrip
+  @Keep
+  val top: Double?,
+  @DoNotStrip
+  @Keep
+  val left: Double?,
+  @DoNotStrip
+  @Keep
+  val bottom: Double?,
+  @DoNotStrip
+  @Keep
+  val right: Double?
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(top: Double?, left: Double?, bottom: Double?, right: Double?): AixContentInsets {
+      return AixContentInsets(top, left, bottom, right)
+    }
+  }
+}

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

@@ -0,0 +1,80 @@
+///
+/// Func_void_AixContentInsets.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 `(insets: struct) => 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_AixContentInsets: (AixContentInsets) -> 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(insets: AixContentInsets): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(insets: struct) => 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_AixContentInsets_cxx: Func_void_AixContentInsets {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(insets: AixContentInsets): Unit
+    = invoke_cxx(insets)
+
+  @FastNative
+  private external fun invoke_cxx(insets: AixContentInsets): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(insets: struct) => void`.
+ * This is implemented in Java/Kotlin, via a `(AixContentInsets) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_AixContentInsets_java(private val function: (AixContentInsets) -> Unit): Func_void_AixContentInsets {
+  @DoNotStrip
+  @Keep
+  override fun invoke(insets: AixContentInsets): Unit {
+    return this.function(insets)
+  }
+}

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

@@ -83,6 +83,26 @@ abstract class HybridAixSpec: HybridView() {
   @set:DoNotStrip
   @set:Keep
   abstract var penultimateCellIndex: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var shouldApplyContentInsets: Boolean?
+  
+  abstract var onWillApplyContentInsets: ((insets: AixContentInsets) -> Unit)?
+  
+  private var onWillApplyContentInsets_cxx: Func_void_AixContentInsets?
+    @Keep
+    @DoNotStrip
+    get() {
+      return onWillApplyContentInsets?.let { Func_void_AixContentInsets_java(it) }
+    }
+    @Keep
+    @DoNotStrip
+    set(value) {
+      onWillApplyContentInsets = value?.let { it }
+    }
 
   // Methods
   @DoNotStrip

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

@@ -16,6 +16,14 @@
 
 namespace margelo::nitro::aix::bridge::swift {
 
+  // pragma MARK: std::function<void(const AixContentInsets& /* insets */)>
+  Func_void_AixContentInsets create_Func_void_AixContentInsets(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = Aix::Func_void_AixContentInsets::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const AixContentInsets& insets) mutable -> void {
+      swiftClosure.call(insets);
+    };
+  }
+  
   // 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

@@ -12,6 +12,8 @@
 namespace margelo::nitro::aix { struct AixAdditionalContentInsetsProp; }
 // Forward declaration of `AixAdditionalContentInsets` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixAdditionalContentInsets; }
+// Forward declaration of `AixContentInsets` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixContentInsets; }
 // Forward declaration of `AixScrollIndicatorInsetValue` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixScrollIndicatorInsetValue; }
 // Forward declaration of `AixScrollIndicatorInsets` to properly resolve imports.
@@ -36,6 +38,7 @@ namespace Aix { class HybridAixSpec_cxx; }
 // Include C++ defined types
 #include "AixAdditionalContentInsets.hpp"
 #include "AixAdditionalContentInsetsProp.hpp"
+#include "AixContentInsets.hpp"
 #include "AixScrollIndicatorInsetValue.hpp"
 #include "AixScrollIndicatorInsets.hpp"
 #include "AixScrollOnFooterSizeUpdate.hpp"
@@ -44,6 +47,7 @@ namespace Aix { class HybridAixSpec_cxx; }
 #include "HybridAixSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <exception>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
@@ -174,6 +178,43 @@ namespace margelo::nitro::aix::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::function<void(const AixContentInsets& /* insets */)>
+  /**
+   * Specialized version of `std::function<void(const AixContentInsets&)>`.
+   */
+  using Func_void_AixContentInsets = std::function<void(const AixContentInsets& /* insets */)>;
+  /**
+   * Wrapper class for a `std::function<void(const AixContentInsets& / * insets * /)>`, this can be used from Swift.
+   */
+  class Func_void_AixContentInsets_Wrapper final {
+  public:
+    explicit Func_void_AixContentInsets_Wrapper(std::function<void(const AixContentInsets& /* insets */)>&& func): _function(std::make_unique<std::function<void(const AixContentInsets& /* insets */)>>(std::move(func))) {}
+    inline void call(AixContentInsets insets) const noexcept {
+      _function->operator()(insets);
+    }
+  private:
+    std::unique_ptr<std::function<void(const AixContentInsets& /* insets */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_AixContentInsets create_Func_void_AixContentInsets(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_AixContentInsets_Wrapper wrap_Func_void_AixContentInsets(Func_void_AixContentInsets value) noexcept {
+    return Func_void_AixContentInsets_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const AixContentInsets& /* insets */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const AixContentInsets& / * insets * /)>>`.
+   */
+  using std__optional_std__function_void_const_AixContentInsets_____insets______ = std::optional<std::function<void(const AixContentInsets& /* insets */)>>;
+  inline std::optional<std::function<void(const AixContentInsets& /* insets */)>> create_std__optional_std__function_void_const_AixContentInsets_____insets______(const std::function<void(const AixContentInsets& /* insets */)>& value) noexcept {
+    return std::optional<std::function<void(const AixContentInsets& /* insets */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_AixContentInsets_____insets______(const std::optional<std::function<void(const AixContentInsets& /* insets */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const AixContentInsets& /* insets */)> get_std__optional_std__function_void_const_AixContentInsets_____insets______(const std::optional<std::function<void(const AixContentInsets& /* insets */)>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<HybridAixSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridAixSpec>`.

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

@@ -12,6 +12,8 @@
 namespace margelo::nitro::aix { struct AixAdditionalContentInsetsProp; }
 // Forward declaration of `AixAdditionalContentInsets` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixAdditionalContentInsets; }
+// Forward declaration of `AixContentInsets` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixContentInsets; }
 // 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,7 @@ namespace margelo::nitro::aix { class HybridAixSpec; }
 // Include C++ defined types
 #include "AixAdditionalContentInsets.hpp"
 #include "AixAdditionalContentInsetsProp.hpp"
+#include "AixContentInsets.hpp"
 #include "AixScrollIndicatorInsetValue.hpp"
 #include "AixScrollIndicatorInsets.hpp"
 #include "AixScrollOnFooterSizeUpdate.hpp"
@@ -36,6 +39,7 @@ namespace margelo::nitro::aix { class HybridAixSpec; }
 #include "HybridAixSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <exception>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>

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

@@ -22,6 +22,8 @@ namespace margelo::nitro::aix { struct AixAdditionalContentInsets; }
 namespace margelo::nitro::aix { struct AixScrollIndicatorInsets; }
 // Forward declaration of `AixScrollIndicatorInsetValue` to properly resolve imports.
 namespace margelo::nitro::aix { struct AixScrollIndicatorInsetValue; }
+// Forward declaration of `AixContentInsets` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixContentInsets; }
 
 #include "AixScrollOnFooterSizeUpdate.hpp"
 #include <optional>
@@ -30,6 +32,8 @@ namespace margelo::nitro::aix { struct AixScrollIndicatorInsetValue; }
 #include "AixScrollIndicatorInsets.hpp"
 #include "AixScrollIndicatorInsetValue.hpp"
 #include <string>
+#include "AixContentInsets.hpp"
+#include <functional>
 
 #include "Aix-Swift-Cxx-Umbrella.hpp"
 
@@ -119,6 +123,20 @@ namespace margelo::nitro::aix {
     inline void setPenultimateCellIndex(std::optional<double> penultimateCellIndex) noexcept override {
       _swiftPart.setPenultimateCellIndex(penultimateCellIndex);
     }
+    inline std::optional<bool> getShouldApplyContentInsets() noexcept override {
+      auto __result = _swiftPart.getShouldApplyContentInsets();
+      return __result;
+    }
+    inline void setShouldApplyContentInsets(std::optional<bool> shouldApplyContentInsets) noexcept override {
+      _swiftPart.setShouldApplyContentInsets(shouldApplyContentInsets);
+    }
+    inline std::optional<std::function<void(const AixContentInsets& /* insets */)>> getOnWillApplyContentInsets() noexcept override {
+      auto __result = _swiftPart.getOnWillApplyContentInsets();
+      return __result;
+    }
+    inline void setOnWillApplyContentInsets(const std::optional<std::function<void(const AixContentInsets& /* insets */)>>& onWillApplyContentInsets) noexcept override {
+      _swiftPart.setOnWillApplyContentInsets(onWillApplyContentInsets);
+    }
 
   public:
     // Methods

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

@@ -106,6 +106,16 @@ using namespace margelo::nitro::aix::views;
     swiftPart.setPenultimateCellIndex(newViewProps.penultimateCellIndex.value);
     newViewProps.penultimateCellIndex.isDirty = false;
   }
+  // shouldApplyContentInsets: optional
+  if (newViewProps.shouldApplyContentInsets.isDirty) {
+    swiftPart.setShouldApplyContentInsets(newViewProps.shouldApplyContentInsets.value);
+    newViewProps.shouldApplyContentInsets.isDirty = false;
+  }
+  // onWillApplyContentInsets: optional
+  if (newViewProps.onWillApplyContentInsets.isDirty) {
+    swiftPart.setOnWillApplyContentInsets(newViewProps.onWillApplyContentInsets.value);
+    newViewProps.onWillApplyContentInsets.isDirty = false;
+  }
 
   swiftPart.afterUpdate();
 

package/nitrogen/generated/ios/swift/AixContentInsets.swift

@@ -0,0 +1,117 @@
+///
+/// AixContentInsets.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `AixContentInsets`, backed by a C++ struct.
+ */
+public typealias AixContentInsets = margelo.nitro.aix.AixContentInsets
+
+public extension AixContentInsets {
+  private typealias bridge = margelo.nitro.aix.bridge.swift
+
+  /**
+   * Create a new instance of `AixContentInsets`.
+   */
+  init(top: Double?, left: Double?, bottom: Double?, right: Double?) {
+    self.init({ () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = top {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = left {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = bottom {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = right {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var top: Double? {
+    @inline(__always)
+    get {
+      return self.__top.value
+    }
+    @inline(__always)
+    set {
+      self.__top = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var left: Double? {
+    @inline(__always)
+    get {
+      return self.__left.value
+    }
+    @inline(__always)
+    set {
+      self.__left = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var bottom: Double? {
+    @inline(__always)
+    get {
+      return self.__bottom.value
+    }
+    @inline(__always)
+    set {
+      self.__bottom = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var right: Double? {
+    @inline(__always)
+    get {
+      return self.__right.value
+    }
+    @inline(__always)
+    set {
+      self.__right = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_AixContentInsets.swift

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

package/nitrogen/generated/ios/swift/HybridAixSpec.swift

@@ -18,6 +18,8 @@ public protocol HybridAixSpec_protocol: HybridObject, HybridView {
   var additionalScrollIndicatorInsets: AixScrollIndicatorInsets? { get set }
   var mainScrollViewID: String? { get set }
   var penultimateCellIndex: Double? { get set }
+  var shouldApplyContentInsets: Bool? { get set }
+  var onWillApplyContentInsets: ((_ insets: AixContentInsets) -> Void)? { get set }
 
   // Methods
   func scrollToEnd(animated: Bool?) throws -> Void

package/nitrogen/generated/ios/swift/HybridAixSpec_cxx.swift

@@ -233,6 +233,62 @@ open class HybridAixSpec_cxx {
       self.__implementation.penultimateCellIndex = newValue.value
     }
   }
+  
+  public final var shouldApplyContentInsets: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.shouldApplyContentInsets {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.shouldApplyContentInsets = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onWillApplyContentInsets: bridge.std__optional_std__function_void_const_AixContentInsets_____insets______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_AixContentInsets_____insets______ in
+        if let __unwrappedValue = self.__implementation.onWillApplyContentInsets {
+          return bridge.create_std__optional_std__function_void_const_AixContentInsets_____insets______({ () -> bridge.Func_void_AixContentInsets in
+            let __closureWrapper = Func_void_AixContentInsets(__unwrappedValue)
+            return bridge.create_Func_void_AixContentInsets(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onWillApplyContentInsets = { () -> ((_ insets: AixContentInsets) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_AixContentInsets_____insets______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_AixContentInsets_____insets______(newValue)
+          return { () -> (AixContentInsets) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_AixContentInsets(__unwrapped)
+            return { (__insets: AixContentInsets) -> Void in
+              __wrappedFunction.call(__insets)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
 
   // Methods
   @inline(__always)

package/nitrogen/generated/shared/c++/AixContentInsets.hpp

@@ -0,0 +1,87 @@
+///
+/// AixContentInsets.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <optional>
+
+namespace margelo::nitro::aix {
+
+  /**
+   * A struct which can be represented as a JavaScript object (AixContentInsets).
+   */
+  struct AixContentInsets {
+  public:
+    std::optional<double> top     SWIFT_PRIVATE;
+    std::optional<double> left     SWIFT_PRIVATE;
+    std::optional<double> bottom     SWIFT_PRIVATE;
+    std::optional<double> right     SWIFT_PRIVATE;
+
+  public:
+    AixContentInsets() = default;
+    explicit AixContentInsets(std::optional<double> top, std::optional<double> left, std::optional<double> bottom, std::optional<double> right): top(top), left(left), bottom(bottom), right(right) {}
+  };
+
+} // namespace margelo::nitro::aix
+
+namespace margelo::nitro {
+
+  // C++ AixContentInsets <> JS AixContentInsets (object)
+  template <>
+  struct JSIConverter<margelo::nitro::aix::AixContentInsets> final {
+    static inline margelo::nitro::aix::AixContentInsets fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::aix::AixContentInsets(
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "top")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "left")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "bottom")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "right"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::aix::AixContentInsets& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "top", JSIConverter<std::optional<double>>::toJSI(runtime, arg.top));
+      obj.setProperty(runtime, "left", JSIConverter<std::optional<double>>::toJSI(runtime, arg.left));
+      obj.setProperty(runtime, "bottom", JSIConverter<std::optional<double>>::toJSI(runtime, arg.bottom));
+      obj.setProperty(runtime, "right", JSIConverter<std::optional<double>>::toJSI(runtime, arg.right));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "top"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "left"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "bottom"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "right"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridAixSpec.cpp

@@ -28,6 +28,10 @@ namespace margelo::nitro::aix {
       prototype.registerHybridSetter("mainScrollViewID", &HybridAixSpec::setMainScrollViewID);
       prototype.registerHybridGetter("penultimateCellIndex", &HybridAixSpec::getPenultimateCellIndex);
       prototype.registerHybridSetter("penultimateCellIndex", &HybridAixSpec::setPenultimateCellIndex);
+      prototype.registerHybridGetter("shouldApplyContentInsets", &HybridAixSpec::getShouldApplyContentInsets);
+      prototype.registerHybridSetter("shouldApplyContentInsets", &HybridAixSpec::setShouldApplyContentInsets);
+      prototype.registerHybridGetter("onWillApplyContentInsets", &HybridAixSpec::getOnWillApplyContentInsets);
+      prototype.registerHybridSetter("onWillApplyContentInsets", &HybridAixSpec::setOnWillApplyContentInsets);
       prototype.registerHybridMethod("scrollToEnd", &HybridAixSpec::scrollToEnd);
       prototype.registerHybridMethod("scrollToIndexWhenBlankSizeReady", &HybridAixSpec::scrollToIndexWhenBlankSizeReady);
     });