react-native-candle 1.0.1 → 19.0.7-beta

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

@@ -0,0 +1,81 @@
+#
+# ReactNativeCandle+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/ReactNativeCandle+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_REACTNATIVECANDLE_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  ReactNativeCandle PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/ReactNativeCandleOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridRNCandleSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridRNCandleSpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  ReactNativeCandle PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        ReactNativeCandle
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        ReactNativeCandle
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        ReactNativeCandle
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/ReactNativeCandle+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// ReactNativeCandle+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/ReactNativeCandle+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 ReactNativeCandle is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/ReactNativeCandleOnLoad.cpp

@@ -0,0 +1,58 @@
+///
+/// ReactNativeCandleOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_REACTNATIVECANDLE_WITH_GENERATED_CMAKE_PROJECT
+#error ReactNativeCandleOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "ReactNativeCandleOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridRNCandleSpec.hpp"
+#include "JFunc_void_LinkedAccount.hpp"
+#include "JFunc_void_TradeExecutionResult.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::rncandle {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::rncandle::registerAllNatives();
+  });
+}
+
+struct JHybridRNCandleSpecImpl: public jni::JavaClass<JHybridRNCandleSpecImpl, JHybridRNCandleSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/HybridRNCandle;";
+  static std::shared_ptr<JHybridRNCandleSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridRNCandleSpecImpl::javaobject()>();
+    jni::local_ref<JHybridRNCandleSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridRNCandleSpec();
+  }
+};
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::rncandle;
+
+  // Register native JNI methods
+  margelo::nitro::rncandle::JHybridRNCandleSpec::CxxPart::registerNatives();
+  margelo::nitro::rncandle::JFunc_void_LinkedAccount_cxx::registerNatives();
+  margelo::nitro::rncandle::JFunc_void_TradeExecutionResult_cxx::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RNCandle",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridRNCandleSpecImpl::create();
+    }
+  );
+}
+
+} // namespace margelo::nitro::rncandle

package/nitrogen/generated/android/ReactNativeCandleOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// ReactNativeCandleOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::rncandle {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of ReactNativeCandle, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all ReactNativeCandle HybridObjects
+   *     margelo::nitro::rncandle::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,58 @@
+///
+/// JACHAccountKind.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 "ACHAccountKind.hpp"
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ACHAccountKind" and the the Kotlin enum "ACHAccountKind".
+   */
+  struct JACHAccountKind final: public jni::JavaClass<JACHAccountKind> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/ACHAccountKind;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ACHAccountKind.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ACHAccountKind toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ACHAccountKind>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JACHAccountKind> fromCpp(ACHAccountKind value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case ACHAccountKind::CHECKING:
+          static const auto fieldCHECKING = clazz->getStaticField<JACHAccountKind>("CHECKING");
+          return clazz->getStaticFieldValue(fieldCHECKING);
+        case ACHAccountKind::SAVINGS:
+          static const auto fieldSAVINGS = clazz->getStaticField<JACHAccountKind>("SAVINGS");
+          return clazz->getStaticFieldValue(fieldSAVINGS);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,67 @@
+///
+/// JACHDetails.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 "ACHDetails.hpp"
+
+#include "ACHAccountKind.hpp"
+#include "JACHAccountKind.hpp"
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ACHDetails" and the the Kotlin data class "ACHDetails".
+   */
+  struct JACHDetails final: public jni::JavaClass<JACHDetails> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/ACHDetails;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ACHDetails by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ACHDetails toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAccountNumber = clazz->getField<jni::JString>("accountNumber");
+      jni::local_ref<jni::JString> accountNumber = this->getFieldValue(fieldAccountNumber);
+      static const auto fieldRoutingNumber = clazz->getField<jni::JString>("routingNumber");
+      jni::local_ref<jni::JString> routingNumber = this->getFieldValue(fieldRoutingNumber);
+      static const auto fieldAccountKind = clazz->getField<JACHAccountKind>("accountKind");
+      jni::local_ref<JACHAccountKind> accountKind = this->getFieldValue(fieldAccountKind);
+      return ACHDetails(
+        accountNumber->toStdString(),
+        routingNumber->toStdString(),
+        accountKind->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JACHDetails::javaobject> fromCpp(const ACHDetails& value) {
+      using JSignature = JACHDetails(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JACHAccountKind>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.accountNumber),
+        jni::make_jstring(value.routingNumber),
+        JACHAccountKind::fromCpp(value.accountKind)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,74 @@
+///
+/// JActiveLinkedAccountDetails.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 "ActiveLinkedAccountDetails.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ActiveLinkedAccountDetails" and the the Kotlin data class "ActiveLinkedAccountDetails".
+   */
+  struct JActiveLinkedAccountDetails final: public jni::JavaClass<JActiveLinkedAccountDetails> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/ActiveLinkedAccountDetails;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ActiveLinkedAccountDetails by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ActiveLinkedAccountDetails toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldState = clazz->getField<jni::JString>("state");
+      jni::local_ref<jni::JString> state = this->getFieldValue(fieldState);
+      static const auto fieldAccountOpened = clazz->getField<jni::JString>("accountOpened");
+      jni::local_ref<jni::JString> accountOpened = this->getFieldValue(fieldAccountOpened);
+      static const auto fieldUsername = clazz->getField<jni::JString>("username");
+      jni::local_ref<jni::JString> username = this->getFieldValue(fieldUsername);
+      static const auto fieldEmailAddress = clazz->getField<jni::JString>("emailAddress");
+      jni::local_ref<jni::JString> emailAddress = this->getFieldValue(fieldEmailAddress);
+      static const auto fieldLegalName = clazz->getField<jni::JString>("legalName");
+      jni::local_ref<jni::JString> legalName = this->getFieldValue(fieldLegalName);
+      return ActiveLinkedAccountDetails(
+        state->toStdString(),
+        accountOpened != nullptr ? std::make_optional(accountOpened->toStdString()) : std::nullopt,
+        username != nullptr ? std::make_optional(username->toStdString()) : std::nullopt,
+        emailAddress != nullptr ? std::make_optional(emailAddress->toStdString()) : std::nullopt,
+        legalName->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<JActiveLinkedAccountDetails::javaobject> fromCpp(const ActiveLinkedAccountDetails& value) {
+      using JSignature = JActiveLinkedAccountDetails(jni::alias_ref<jni::JString>, 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.state),
+        value.accountOpened.has_value() ? jni::make_jstring(value.accountOpened.value()) : nullptr,
+        value.username.has_value() ? jni::make_jstring(value.username.value()) : nullptr,
+        value.emailAddress.has_value() ? jni::make_jstring(value.emailAddress.value()) : nullptr,
+        jni::make_jstring(value.legalName)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,57 @@
+///
+/// JAddress.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 "Address.hpp"
+
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Address" and the the Kotlin data class "Address".
+   */
+  struct JAddress final: public jni::JavaClass<JAddress> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/Address;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Address by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Address toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldValue = clazz->getField<jni::JString>("value");
+      jni::local_ref<jni::JString> value = this->getFieldValue(fieldValue);
+      return Address(
+        value->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<JAddress::javaobject> fromCpp(const Address& value) {
+      using JSignature = JAddress(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.value)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,90 @@
+///
+/// JAssetAccount.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 "AssetAccount.hpp"
+
+#include "ACHAccountKind.hpp"
+#include "ACHDetails.hpp"
+#include "CryptoAccount.hpp"
+#include "FiatAccount.hpp"
+#include "FinancialAccountKind.hpp"
+#include "JACHAccountKind.hpp"
+#include "JACHDetails.hpp"
+#include "JCryptoAccount.hpp"
+#include "JFiatAccount.hpp"
+#include "JFinancialAccountKind.hpp"
+#include "JService.hpp"
+#include "JStockAccount.hpp"
+#include "JTransportAccount.hpp"
+#include "JTransportAccountKind.hpp"
+#include "JWireDetails.hpp"
+#include "Service.hpp"
+#include "StockAccount.hpp"
+#include "TransportAccount.hpp"
+#include "TransportAccountKind.hpp"
+#include "WireDetails.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AssetAccount" and the the Kotlin data class "AssetAccount".
+   */
+  struct JAssetAccount final: public jni::JavaClass<JAssetAccount> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/AssetAccount;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AssetAccount by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AssetAccount toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldFiatAccount = clazz->getField<JFiatAccount>("fiatAccount");
+      jni::local_ref<JFiatAccount> fiatAccount = this->getFieldValue(fieldFiatAccount);
+      static const auto fieldCryptoAccount = clazz->getField<JCryptoAccount>("cryptoAccount");
+      jni::local_ref<JCryptoAccount> cryptoAccount = this->getFieldValue(fieldCryptoAccount);
+      static const auto fieldStockAccount = clazz->getField<JStockAccount>("stockAccount");
+      jni::local_ref<JStockAccount> stockAccount = this->getFieldValue(fieldStockAccount);
+      static const auto fieldTransportAccount = clazz->getField<JTransportAccount>("transportAccount");
+      jni::local_ref<JTransportAccount> transportAccount = this->getFieldValue(fieldTransportAccount);
+      return AssetAccount(
+        fiatAccount != nullptr ? std::make_optional(fiatAccount->toCpp()) : std::nullopt,
+        cryptoAccount != nullptr ? std::make_optional(cryptoAccount->toCpp()) : std::nullopt,
+        stockAccount != nullptr ? std::make_optional(stockAccount->toCpp()) : std::nullopt,
+        transportAccount != nullptr ? std::make_optional(transportAccount->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<JAssetAccount::javaobject> fromCpp(const AssetAccount& value) {
+      using JSignature = JAssetAccount(jni::alias_ref<JFiatAccount>, jni::alias_ref<JCryptoAccount>, jni::alias_ref<JStockAccount>, jni::alias_ref<JTransportAccount>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.fiatAccount.has_value() ? JFiatAccount::fromCpp(value.fiatAccount.value()) : nullptr,
+        value.cryptoAccount.has_value() ? JCryptoAccount::fromCpp(value.cryptoAccount.value()) : nullptr,
+        value.stockAccount.has_value() ? JStockAccount::fromCpp(value.stockAccount.value()) : nullptr,
+        value.transportAccount.has_value() ? JTransportAccount::fromCpp(value.transportAccount.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,64 @@
+///
+/// JAssetAccountKind.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 "AssetAccountKind.hpp"
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AssetAccountKind" and the the Kotlin enum "AssetAccountKind".
+   */
+  struct JAssetAccountKind final: public jni::JavaClass<JAssetAccountKind> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/AssetAccountKind;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AssetAccountKind.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AssetAccountKind toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AssetAccountKind>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAssetAccountKind> fromCpp(AssetAccountKind value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case AssetAccountKind::FIAT:
+          static const auto fieldFIAT = clazz->getStaticField<JAssetAccountKind>("FIAT");
+          return clazz->getStaticFieldValue(fieldFIAT);
+        case AssetAccountKind::STOCK:
+          static const auto fieldSTOCK = clazz->getStaticField<JAssetAccountKind>("STOCK");
+          return clazz->getStaticFieldValue(fieldSTOCK);
+        case AssetAccountKind::CRYPTO:
+          static const auto fieldCRYPTO = clazz->getStaticField<JAssetAccountKind>("CRYPTO");
+          return clazz->getStaticFieldValue(fieldCRYPTO);
+        case AssetAccountKind::TRANSPORT:
+          static const auto fieldTRANSPORT = clazz->getStaticField<JAssetAccountKind>("TRANSPORT");
+          return clazz->getStaticFieldValue(fieldTRANSPORT);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::rncandle