react-native-litert-lm 0.1.0

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

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_std__string_bool.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(token: String, done: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string_bool: public jni::JavaClass<JFunc_void_std__string_bool> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/Func_void_std__string_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string_bool` instance holds through JNI.
+     */
+    void invoke(const std::string& token, bool done) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* token */, jboolean /* done */)>("invoke");
+      method(self(), jni::make_jstring(token), done);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string_bool that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_bool_cxx final: public jni::HybridClass<JFunc_void_std__string_bool_cxx, JFunc_void_std__string_bool> {
+  public:
+    static jni::local_ref<JFunc_void_std__string_bool::javaobject> fromCpp(const std::function<void(const std::string& /* token */, bool /* done */)>& func) {
+      return JFunc_void_std__string_bool_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_bool_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> token, jboolean done) {
+      _func(token->toStdString(), static_cast<bool>(done));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* token */, bool /* done */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/Func_void_std__string_bool_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_bool_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_bool_cxx(const std::function<void(const std::string& /* token */, bool /* done */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* token */, bool /* done */)> _func;
+  };
+
+} // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,77 @@
+///
+/// JGenerationStats.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "GenerationStats.hpp"
+
+
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "GenerationStats" and the the Kotlin data class "GenerationStats".
+   */
+  struct JGenerationStats final: public jni::JavaClass<JGenerationStats> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/GenerationStats;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct GenerationStats by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    GenerationStats toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPromptTokens = clazz->getField<double>("promptTokens");
+      double promptTokens = this->getFieldValue(fieldPromptTokens);
+      static const auto fieldCompletionTokens = clazz->getField<double>("completionTokens");
+      double completionTokens = this->getFieldValue(fieldCompletionTokens);
+      static const auto fieldTotalTokens = clazz->getField<double>("totalTokens");
+      double totalTokens = this->getFieldValue(fieldTotalTokens);
+      static const auto fieldTimeToFirstToken = clazz->getField<double>("timeToFirstToken");
+      double timeToFirstToken = this->getFieldValue(fieldTimeToFirstToken);
+      static const auto fieldTotalTime = clazz->getField<double>("totalTime");
+      double totalTime = this->getFieldValue(fieldTotalTime);
+      static const auto fieldTokensPerSecond = clazz->getField<double>("tokensPerSecond");
+      double tokensPerSecond = this->getFieldValue(fieldTokensPerSecond);
+      return GenerationStats(
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        timeToFirstToken,
+        totalTime,
+        tokensPerSecond
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JGenerationStats::javaobject> fromCpp(const GenerationStats& value) {
+      using JSignature = JGenerationStats(double, double, double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.promptTokens,
+        value.completionTokens,
+        value.totalTokens,
+        value.timeToFirstToken,
+        value.totalTime,
+        value.tokensPerSecond
+      );
+    }
+  };
+
+} // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,133 @@
+///
+/// JHybridLiteRTLMSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridLiteRTLMSpec.hpp"
+
+// Forward declaration of `Message` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct Message; }
+// Forward declaration of `Role` to properly resolve imports.
+namespace margelo::nitro::litertlm { enum class Role; }
+// Forward declaration of `GenerationStats` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct GenerationStats; }
+// Forward declaration of `LLMConfig` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct LLMConfig; }
+// Forward declaration of `Backend` to properly resolve imports.
+namespace margelo::nitro::litertlm { enum class Backend; }
+
+#include <string>
+#include "Message.hpp"
+#include <vector>
+#include "JMessage.hpp"
+#include "Role.hpp"
+#include "JRole.hpp"
+#include "GenerationStats.hpp"
+#include "JGenerationStats.hpp"
+#include "LLMConfig.hpp"
+#include <optional>
+#include "JLLMConfig.hpp"
+#include "Backend.hpp"
+#include "JBackend.hpp"
+#include <functional>
+#include "JFunc_void_std__string_bool.hpp"
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::litertlm {
+
+  jni::local_ref<JHybridLiteRTLMSpec::jhybriddata> JHybridLiteRTLMSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridLiteRTLMSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridLiteRTLMSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridLiteRTLMSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  bool JHybridLiteRTLMSpec::equals(const std::shared_ptr<HybridObject>& other) {
+    if (auto otherCast = std::dynamic_pointer_cast<JHybridLiteRTLMSpec>(other)) {
+      return _javaPart == otherCast->_javaPart;
+    }
+    return false;
+  }
+
+  void JHybridLiteRTLMSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridLiteRTLMSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridLiteRTLMSpec::loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* modelPath */, jni::alias_ref<JLLMConfig> /* config */)>("loadModel");
+    method(_javaPart, jni::make_jstring(modelPath), config.has_value() ? JLLMConfig::fromCpp(config.value()) : nullptr);
+  }
+  std::string JHybridLiteRTLMSpec::sendMessage(const std::string& message) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* message */)>("sendMessage");
+    auto __result = method(_javaPart, jni::make_jstring(message));
+    return __result->toStdString();
+  }
+  std::string JHybridLiteRTLMSpec::sendMessageWithImage(const std::string& message, const std::string& imagePath) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* imagePath */)>("sendMessageWithImage");
+    auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(imagePath));
+    return __result->toStdString();
+  }
+  std::string JHybridLiteRTLMSpec::sendMessageWithAudio(const std::string& message, const std::string& audioPath) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* audioPath */)>("sendMessageWithAudio");
+    auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(audioPath));
+    return __result->toStdString();
+  }
+  void JHybridLiteRTLMSpec::sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<JFunc_void_std__string_bool::javaobject> /* onToken */)>("sendMessageAsync_cxx");
+    method(_javaPart, jni::make_jstring(message), JFunc_void_std__string_bool_cxx::fromCpp(onToken));
+  }
+  std::vector<Message> JHybridLiteRTLMSpec::getHistory() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JMessage>>()>("getHistory");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<Message> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }();
+  }
+  void JHybridLiteRTLMSpec::resetConversation() {
+    static const auto method = javaClassStatic()->getMethod<void()>("resetConversation");
+    method(_javaPart);
+  }
+  bool JHybridLiteRTLMSpec::isReady() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isReady");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  GenerationStats JHybridLiteRTLMSpec::getStats() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JGenerationStats>()>("getStats");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridLiteRTLMSpec::close() {
+    static const auto method = javaClassStatic()->getMethod<void()>("close");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,75 @@
+///
+/// HybridLiteRTLMSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridLiteRTLMSpec.hpp"
+
+
+
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  class JHybridLiteRTLMSpec: public jni::HybridClass<JHybridLiteRTLMSpec, JHybridObject>,
+                             public virtual HybridLiteRTLMSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/HybridLiteRTLMSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridLiteRTLMSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridLiteRTLMSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridLiteRTLMSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    bool equals(const std::shared_ptr<HybridObject>& other) override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridLiteRTLMSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) override;
+    std::string sendMessage(const std::string& message) override;
+    std::string sendMessageWithImage(const std::string& message, const std::string& imagePath) override;
+    std::string sendMessageWithAudio(const std::string& message, const std::string& audioPath) override;
+    void sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) override;
+    std::vector<Message> getHistory() override;
+    void resetConversation() override;
+    bool isReady() override;
+    GenerationStats getStats() override;
+    void close() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridLiteRTLMSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,75 @@
+///
+/// JLLMConfig.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "LLMConfig.hpp"
+
+#include "Backend.hpp"
+#include "JBackend.hpp"
+#include <optional>
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LLMConfig" and the the Kotlin data class "LLMConfig".
+   */
+  struct JLLMConfig final: public jni::JavaClass<JLLMConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/LLMConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LLMConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LLMConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldBackend = clazz->getField<JBackend>("backend");
+      jni::local_ref<JBackend> backend = this->getFieldValue(fieldBackend);
+      static const auto fieldMaxTokens = clazz->getField<jni::JDouble>("maxTokens");
+      jni::local_ref<jni::JDouble> maxTokens = this->getFieldValue(fieldMaxTokens);
+      static const auto fieldTemperature = clazz->getField<jni::JDouble>("temperature");
+      jni::local_ref<jni::JDouble> temperature = this->getFieldValue(fieldTemperature);
+      static const auto fieldTopK = clazz->getField<jni::JDouble>("topK");
+      jni::local_ref<jni::JDouble> topK = this->getFieldValue(fieldTopK);
+      static const auto fieldTopP = clazz->getField<jni::JDouble>("topP");
+      jni::local_ref<jni::JDouble> topP = this->getFieldValue(fieldTopP);
+      return LLMConfig(
+        backend != nullptr ? std::make_optional(backend->toCpp()) : std::nullopt,
+        maxTokens != nullptr ? std::make_optional(maxTokens->value()) : std::nullopt,
+        temperature != nullptr ? std::make_optional(temperature->value()) : std::nullopt,
+        topK != nullptr ? std::make_optional(topK->value()) : std::nullopt,
+        topP != nullptr ? std::make_optional(topP->value()) : 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<JLLMConfig::javaobject> fromCpp(const LLMConfig& value) {
+      using JSignature = JLLMConfig(jni::alias_ref<JBackend>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.backend.has_value() ? JBackend::fromCpp(value.backend.value()) : nullptr,
+        value.maxTokens.has_value() ? jni::JDouble::valueOf(value.maxTokens.value()) : nullptr,
+        value.temperature.has_value() ? jni::JDouble::valueOf(value.temperature.value()) : nullptr,
+        value.topK.has_value() ? jni::JDouble::valueOf(value.topK.value()) : nullptr,
+        value.topP.has_value() ? jni::JDouble::valueOf(value.topP.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,63 @@
+///
+/// JMessage.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Message.hpp"
+
+#include "JRole.hpp"
+#include "Role.hpp"
+#include <string>
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Message" and the the Kotlin data class "Message".
+   */
+  struct JMessage final: public jni::JavaClass<JMessage> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/Message;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Message by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Message toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldRole = clazz->getField<JRole>("role");
+      jni::local_ref<JRole> role = this->getFieldValue(fieldRole);
+      static const auto fieldContent = clazz->getField<jni::JString>("content");
+      jni::local_ref<jni::JString> content = this->getFieldValue(fieldContent);
+      return Message(
+        role->toCpp(),
+        content->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMessage::javaobject> fromCpp(const Message& value) {
+      using JSignature = JMessage(jni::alias_ref<JRole>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JRole::fromCpp(value.role),
+        jni::make_jstring(value.content)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::litertlm

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

@@ -0,0 +1,61 @@
+///
+/// JRole.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Role.hpp"
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "Role" and the the Kotlin enum "Role".
+   */
+  struct JRole final: public jni::JavaClass<JRole> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/Role;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum Role.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Role toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<Role>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRole> fromCpp(Role value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case Role::USER:
+          static const auto fieldUSER = clazz->getStaticField<JRole>("USER");
+          return clazz->getStaticFieldValue(fieldUSER);
+        case Role::MODEL:
+          static const auto fieldMODEL = clazz->getStaticField<JRole>("MODEL");
+          return clazz->getStaticFieldValue(fieldMODEL);
+        case Role::SYSTEM:
+          static const auto fieldSYSTEM = clazz->getStaticField<JRole>("SYSTEM");
+          return clazz->getStaticFieldValue(fieldSYSTEM);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::litertlm

package/nitrogen/generated/android/kotlin/com/margelo/nitro/dev/litert/litertlm/Backend.kt

@@ -0,0 +1,24 @@
+///
+/// Backend.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.dev.litert.litertlm
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "Backend".
+ */
+@DoNotStrip
+@Keep
+enum class Backend(@DoNotStrip @Keep val value: Int) {
+  CPU(0),
+  GPU(1),
+  NPU(2);
+
+  companion object
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/dev/litert/litertlm/Func_void_std__string_bool.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_std__string_bool.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.dev.litert.litertlm
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(token: string, done: 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_std__string_bool: (String, 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(token: String, done: Boolean): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(token: string, done: 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_std__string_bool_cxx: Func_void_std__string_bool {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(token: String, done: Boolean): Unit
+    = invoke_cxx(token,done)
+
+  @FastNative
+  private external fun invoke_cxx(token: String, done: Boolean): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(token: string, done: boolean) => void`.
+ * This is implemented in Java/Kotlin, via a `(String, Boolean) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_std__string_bool_java(private val function: (String, Boolean) -> Unit): Func_void_std__string_bool {
+  @DoNotStrip
+  @Keep
+  override fun invoke(token: String, done: Boolean): Unit {
+    return this.function(token, done)
+  }
+}