aix 0.6.0 → 0.6.2

package/ios/PasteFileManager.swift

@@ -0,0 +1,92 @@
+import UIKit
+
+enum PasteFileManager {
+
+    private static let pasteDir: URL = {
+        let tmp = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
+        return tmp.appendingPathComponent("paste", isDirectory: true)
+    }()
+
+    /// Maximum age for paste files before cleanup (1 hour).
+    private static let maxFileAge: TimeInterval = 3600
+
+    static func save(image: UIImage) throws -> String {
+        let data: Data
+        let ext: String
+        if let png = image.pngData() {
+            data = png
+            ext = "png"
+        } else if let jpg = image.jpegData(compressionQuality: 0.9) {
+            data = jpg
+            ext = "jpg"
+        } else {
+            throw NSError(
+                domain: "SaveImageError",
+                code: 3,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to encode image as PNG or JPEG"]
+            )
+        }
+
+        return try writeToDir(data: data, fileExtension: ext)
+    }
+
+    static func save(text: String) throws -> String {
+        guard let data = text.data(using: .utf8) else {
+            throw NSError(
+                domain: "SaveTextError",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to encode text as UTF-8"]
+            )
+        }
+
+        return try writeToDir(data: data, fileExtension: "txt")
+    }
+
+    static func save(data: Data, fileExtension: String) throws -> String {
+        let sanitizedExt = fileExtension.trimmingCharacters(in: .whitespacesAndNewlines)
+        return try writeToDir(data: data, fileExtension: sanitizedExt)
+    }
+
+    // MARK: - Cleanup
+
+    /// Removes paste files older than `maxFileAge`.
+    static func cleanupOldFiles() {
+        let fileManager = FileManager.default
+        guard let contents = try? fileManager.contentsOfDirectory(
+            at: pasteDir,
+            includingPropertiesForKeys: [.creationDateKey],
+            options: .skipsHiddenFiles
+        ) else { return }
+
+        let cutoff = Date().addingTimeInterval(-maxFileAge)
+        var removed = 0
+
+        for fileURL in contents {
+            guard let attrs = try? fileURL.resourceValues(forKeys: [.creationDateKey]),
+                  let created = attrs.creationDate,
+                  created < cutoff else { continue }
+            try? fileManager.removeItem(at: fileURL)
+            removed += 1
+        }
+
+        if removed > 0 {
+            print("[PasteFileManager] Cleaned up \(removed) old paste file(s)")
+        }
+    }
+
+    // MARK: - Private
+    private static func writeToDir(data: Data, fileExtension: String) throws -> String {
+        let fileManager = FileManager.default
+
+        if !fileManager.fileExists(atPath: pasteDir.path) {
+            try fileManager.createDirectory(at: pasteDir, withIntermediateDirectories: true, attributes: nil)
+        }
+
+        let fileName = UUID().uuidString + "." + fileExtension
+        let fileURL = pasteDir.appendingPathComponent(fileName)
+
+        try data.write(to: fileURL, options: .atomic)
+
+        return fileURL.path
+    }
+}

package/nitro.json

@@ -20,6 +20,14 @@
     "AixComposer": {
       "swift": "HybridAixComposer",
       "kotlin": "HybridAixComposer"
+    },
+    "AixInputWrapper": {
+      "swift": "HybridAixInputWrapper",
+      "kotlin": "HybridAixInputWrapper"
+    },
+    "AixDropzone": {
+      "swift": "HybridAixDropzone",
+      "kotlin": "HybridAixDropzone"
     }
   },
   "ignorePaths": ["**/node_modules"]

package/nitrogen/generated/android/Aix+autolinking.cmake

@@ -39,6 +39,10 @@ target_sources(
   ../nitrogen/generated/shared/c++/views/HybridAixCellViewComponent.cpp
   ../nitrogen/generated/shared/c++/HybridAixComposerSpec.cpp
   ../nitrogen/generated/shared/c++/views/HybridAixComposerComponent.cpp
+  ../nitrogen/generated/shared/c++/HybridAixInputWrapperSpec.cpp
+  ../nitrogen/generated/shared/c++/views/HybridAixInputWrapperComponent.cpp
+  ../nitrogen/generated/shared/c++/HybridAixDropzoneSpec.cpp
+  ../nitrogen/generated/shared/c++/views/HybridAixDropzoneComponent.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridAixSpec.cpp
   ../nitrogen/generated/android/c++/views/JHybridAixStateUpdater.cpp
@@ -46,6 +50,10 @@ target_sources(
   ../nitrogen/generated/android/c++/views/JHybridAixCellViewStateUpdater.cpp
   ../nitrogen/generated/android/c++/JHybridAixComposerSpec.cpp
   ../nitrogen/generated/android/c++/views/JHybridAixComposerStateUpdater.cpp
+  ../nitrogen/generated/android/c++/JHybridAixInputWrapperSpec.cpp
+  ../nitrogen/generated/android/c++/views/JHybridAixInputWrapperStateUpdater.cpp
+  ../nitrogen/generated/android/c++/JHybridAixDropzoneSpec.cpp
+  ../nitrogen/generated/android/c++/views/JHybridAixDropzoneStateUpdater.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

package/nitrogen/generated/android/AixOnLoad.cpp

@@ -23,6 +23,11 @@
 #include "views/JHybridAixCellViewStateUpdater.hpp"
 #include "JHybridAixComposerSpec.hpp"
 #include "views/JHybridAixComposerStateUpdater.hpp"
+#include "JHybridAixInputWrapperSpec.hpp"
+#include "JFunc_void_std__vector_AixInputWrapperOnPasteEvent_.hpp"
+#include "views/JHybridAixInputWrapperStateUpdater.hpp"
+#include "JHybridAixDropzoneSpec.hpp"
+#include "views/JHybridAixDropzoneStateUpdater.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::aix {
@@ -42,6 +47,11 @@ int initialize(JavaVM* vm) {
     margelo::nitro::aix::views::JHybridAixCellViewStateUpdater::registerNatives();
     margelo::nitro::aix::JHybridAixComposerSpec::registerNatives();
     margelo::nitro::aix::views::JHybridAixComposerStateUpdater::registerNatives();
+    margelo::nitro::aix::JHybridAixInputWrapperSpec::registerNatives();
+    margelo::nitro::aix::JFunc_void_std__vector_AixInputWrapperOnPasteEvent__cxx::registerNatives();
+    margelo::nitro::aix::views::JHybridAixInputWrapperStateUpdater::registerNatives();
+    margelo::nitro::aix::JHybridAixDropzoneSpec::registerNatives();
+    margelo::nitro::aix::views::JHybridAixDropzoneStateUpdater::registerNatives();
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(
@@ -68,6 +78,22 @@ int initialize(JavaVM* vm) {
         return instance->cthis()->shared();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "AixInputWrapper",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridAixInputWrapperSpec::javaobject> object("com/aix/HybridAixInputWrapper");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "AixDropzone",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridAixDropzoneSpec::javaobject> object("com/aix/HybridAixDropzone");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
   });
 }
 

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