react-native-candle 1.0.1 → 19.0.7-beta

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

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

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

@@ -0,0 +1,108 @@
+///
+/// JTrade.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 "Trade.hpp"
+
+#include "Address.hpp"
+#include "Coordinates.hpp"
+#include "Counterparty.hpp"
+#include "CryptoAsset.hpp"
+#include "EventAsset.hpp"
+#include "FiatAsset.hpp"
+#include "JAddress.hpp"
+#include "JCoordinates.hpp"
+#include "JCounterparty.hpp"
+#include "JCryptoAsset.hpp"
+#include "JEventAsset.hpp"
+#include "JFiatAsset.hpp"
+#include "JMerchantCounterparty.hpp"
+#include "JMerchantLocation.hpp"
+#include "JNothingAsset.hpp"
+#include "JOtherAsset.hpp"
+#include "JService.hpp"
+#include "JServiceCounterparty.hpp"
+#include "JStockAsset.hpp"
+#include "JTradeAsset.hpp"
+#include "JTradeState.hpp"
+#include "JTransportAsset.hpp"
+#include "JUserCounterparty.hpp"
+#include "MerchantCounterparty.hpp"
+#include "MerchantLocation.hpp"
+#include "NothingAsset.hpp"
+#include "OtherAsset.hpp"
+#include "Service.hpp"
+#include "ServiceCounterparty.hpp"
+#include "StockAsset.hpp"
+#include "TradeAsset.hpp"
+#include "TradeState.hpp"
+#include "TransportAsset.hpp"
+#include "UserCounterparty.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Trade" and the the Kotlin data class "Trade".
+   */
+  struct JTrade final: public jni::JavaClass<JTrade> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/Trade;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Trade by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Trade toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDateTime = clazz->getField<jni::JString>("dateTime");
+      jni::local_ref<jni::JString> dateTime = this->getFieldValue(fieldDateTime);
+      static const auto fieldState = clazz->getField<JTradeState>("state");
+      jni::local_ref<JTradeState> state = this->getFieldValue(fieldState);
+      static const auto fieldCounterparty = clazz->getField<JCounterparty>("counterparty");
+      jni::local_ref<JCounterparty> counterparty = this->getFieldValue(fieldCounterparty);
+      static const auto fieldLost = clazz->getField<JTradeAsset>("lost");
+      jni::local_ref<JTradeAsset> lost = this->getFieldValue(fieldLost);
+      static const auto fieldGained = clazz->getField<JTradeAsset>("gained");
+      jni::local_ref<JTradeAsset> gained = this->getFieldValue(fieldGained);
+      return Trade(
+        dateTime->toStdString(),
+        state->toCpp(),
+        counterparty->toCpp(),
+        lost->toCpp(),
+        gained->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<JTrade::javaobject> fromCpp(const Trade& value) {
+      using JSignature = JTrade(jni::alias_ref<jni::JString>, jni::alias_ref<JTradeState>, jni::alias_ref<JCounterparty>, jni::alias_ref<JTradeAsset>, jni::alias_ref<JTradeAsset>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.dateTime),
+        JTradeState::fromCpp(value.state),
+        JCounterparty::fromCpp(value.counterparty),
+        JTradeAsset::fromCpp(value.lost),
+        JTradeAsset::fromCpp(value.gained)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,102 @@
+///
+/// JTradeAsset.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 "TradeAsset.hpp"
+
+#include "Address.hpp"
+#include "Coordinates.hpp"
+#include "CryptoAsset.hpp"
+#include "EventAsset.hpp"
+#include "FiatAsset.hpp"
+#include "JAddress.hpp"
+#include "JCoordinates.hpp"
+#include "JCryptoAsset.hpp"
+#include "JEventAsset.hpp"
+#include "JFiatAsset.hpp"
+#include "JNothingAsset.hpp"
+#include "JOtherAsset.hpp"
+#include "JService.hpp"
+#include "JStockAsset.hpp"
+#include "JTransportAsset.hpp"
+#include "NothingAsset.hpp"
+#include "OtherAsset.hpp"
+#include "Service.hpp"
+#include "StockAsset.hpp"
+#include "TransportAsset.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "TradeAsset" and the the Kotlin data class "TradeAsset".
+   */
+  struct JTradeAsset final: public jni::JavaClass<JTradeAsset> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/TradeAsset;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct TradeAsset by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    TradeAsset toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldFiatAsset = clazz->getField<JFiatAsset>("fiatAsset");
+      jni::local_ref<JFiatAsset> fiatAsset = this->getFieldValue(fieldFiatAsset);
+      static const auto fieldCryptoAsset = clazz->getField<JCryptoAsset>("cryptoAsset");
+      jni::local_ref<JCryptoAsset> cryptoAsset = this->getFieldValue(fieldCryptoAsset);
+      static const auto fieldStockAsset = clazz->getField<JStockAsset>("stockAsset");
+      jni::local_ref<JStockAsset> stockAsset = this->getFieldValue(fieldStockAsset);
+      static const auto fieldTransportAsset = clazz->getField<JTransportAsset>("transportAsset");
+      jni::local_ref<JTransportAsset> transportAsset = this->getFieldValue(fieldTransportAsset);
+      static const auto fieldEventAsset = clazz->getField<JEventAsset>("eventAsset");
+      jni::local_ref<JEventAsset> eventAsset = this->getFieldValue(fieldEventAsset);
+      static const auto fieldOtherAsset = clazz->getField<JOtherAsset>("otherAsset");
+      jni::local_ref<JOtherAsset> otherAsset = this->getFieldValue(fieldOtherAsset);
+      static const auto fieldNothingAsset = clazz->getField<JNothingAsset>("nothingAsset");
+      jni::local_ref<JNothingAsset> nothingAsset = this->getFieldValue(fieldNothingAsset);
+      return TradeAsset(
+        fiatAsset != nullptr ? std::make_optional(fiatAsset->toCpp()) : std::nullopt,
+        cryptoAsset != nullptr ? std::make_optional(cryptoAsset->toCpp()) : std::nullopt,
+        stockAsset != nullptr ? std::make_optional(stockAsset->toCpp()) : std::nullopt,
+        transportAsset != nullptr ? std::make_optional(transportAsset->toCpp()) : std::nullopt,
+        eventAsset != nullptr ? std::make_optional(eventAsset->toCpp()) : std::nullopt,
+        otherAsset != nullptr ? std::make_optional(otherAsset->toCpp()) : std::nullopt,
+        nothingAsset != nullptr ? std::make_optional(nothingAsset->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<JTradeAsset::javaobject> fromCpp(const TradeAsset& value) {
+      using JSignature = JTradeAsset(jni::alias_ref<JFiatAsset>, jni::alias_ref<JCryptoAsset>, jni::alias_ref<JStockAsset>, jni::alias_ref<JTransportAsset>, jni::alias_ref<JEventAsset>, jni::alias_ref<JOtherAsset>, jni::alias_ref<JNothingAsset>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.fiatAsset.has_value() ? JFiatAsset::fromCpp(value.fiatAsset.value()) : nullptr,
+        value.cryptoAsset.has_value() ? JCryptoAsset::fromCpp(value.cryptoAsset.value()) : nullptr,
+        value.stockAsset.has_value() ? JStockAsset::fromCpp(value.stockAsset.value()) : nullptr,
+        value.transportAsset.has_value() ? JTransportAsset::fromCpp(value.transportAsset.value()) : nullptr,
+        value.eventAsset.has_value() ? JEventAsset::fromCpp(value.eventAsset.value()) : nullptr,
+        value.otherAsset.has_value() ? JOtherAsset::fromCpp(value.otherAsset.value()) : nullptr,
+        value.nothingAsset.has_value() ? JNothingAsset::fromCpp(value.nothingAsset.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

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

@@ -0,0 +1,100 @@
+///
+/// JTradeAssetQuoteRequest.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 "TradeAssetQuoteRequest.hpp"
+
+#include "Address.hpp"
+#include "Coordinates.hpp"
+#include "CryptoAssetQuoteRequest.hpp"
+#include "EventAssetQuoteRequest.hpp"
+#include "FiatAssetQuoteRequest.hpp"
+#include "JAddress.hpp"
+#include "JCoordinates.hpp"
+#include "JCryptoAssetQuoteRequest.hpp"
+#include "JEventAssetQuoteRequest.hpp"
+#include "JFiatAssetQuoteRequest.hpp"
+#include "JNothingAssetQuoteRequest.hpp"
+#include "JOtherAssetQuoteRequest.hpp"
+#include "JStockAssetQuoteRequest.hpp"
+#include "JTransportAssetQuoteRequest.hpp"
+#include "NothingAssetQuoteRequest.hpp"
+#include "OtherAssetQuoteRequest.hpp"
+#include "StockAssetQuoteRequest.hpp"
+#include "TransportAssetQuoteRequest.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "TradeAssetQuoteRequest" and the the Kotlin data class "TradeAssetQuoteRequest".
+   */
+  struct JTradeAssetQuoteRequest final: public jni::JavaClass<JTradeAssetQuoteRequest> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/TradeAssetQuoteRequest;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct TradeAssetQuoteRequest by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    TradeAssetQuoteRequest toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldFiatAssetQuoteRequest = clazz->getField<JFiatAssetQuoteRequest>("fiatAssetQuoteRequest");
+      jni::local_ref<JFiatAssetQuoteRequest> fiatAssetQuoteRequest = this->getFieldValue(fieldFiatAssetQuoteRequest);
+      static const auto fieldCryptoAssetQuoteRequest = clazz->getField<JCryptoAssetQuoteRequest>("cryptoAssetQuoteRequest");
+      jni::local_ref<JCryptoAssetQuoteRequest> cryptoAssetQuoteRequest = this->getFieldValue(fieldCryptoAssetQuoteRequest);
+      static const auto fieldStockAssetQuoteRequest = clazz->getField<JStockAssetQuoteRequest>("stockAssetQuoteRequest");
+      jni::local_ref<JStockAssetQuoteRequest> stockAssetQuoteRequest = this->getFieldValue(fieldStockAssetQuoteRequest);
+      static const auto fieldTransportAssetQuoteRequest = clazz->getField<JTransportAssetQuoteRequest>("transportAssetQuoteRequest");
+      jni::local_ref<JTransportAssetQuoteRequest> transportAssetQuoteRequest = this->getFieldValue(fieldTransportAssetQuoteRequest);
+      static const auto fieldEventAssetQuoteRequest = clazz->getField<JEventAssetQuoteRequest>("eventAssetQuoteRequest");
+      jni::local_ref<JEventAssetQuoteRequest> eventAssetQuoteRequest = this->getFieldValue(fieldEventAssetQuoteRequest);
+      static const auto fieldNothingAssetQuoteRequest = clazz->getField<JNothingAssetQuoteRequest>("nothingAssetQuoteRequest");
+      jni::local_ref<JNothingAssetQuoteRequest> nothingAssetQuoteRequest = this->getFieldValue(fieldNothingAssetQuoteRequest);
+      static const auto fieldOtherAssetQuoteRequest = clazz->getField<JOtherAssetQuoteRequest>("otherAssetQuoteRequest");
+      jni::local_ref<JOtherAssetQuoteRequest> otherAssetQuoteRequest = this->getFieldValue(fieldOtherAssetQuoteRequest);
+      return TradeAssetQuoteRequest(
+        fiatAssetQuoteRequest != nullptr ? std::make_optional(fiatAssetQuoteRequest->toCpp()) : std::nullopt,
+        cryptoAssetQuoteRequest != nullptr ? std::make_optional(cryptoAssetQuoteRequest->toCpp()) : std::nullopt,
+        stockAssetQuoteRequest != nullptr ? std::make_optional(stockAssetQuoteRequest->toCpp()) : std::nullopt,
+        transportAssetQuoteRequest != nullptr ? std::make_optional(transportAssetQuoteRequest->toCpp()) : std::nullopt,
+        eventAssetQuoteRequest != nullptr ? std::make_optional(eventAssetQuoteRequest->toCpp()) : std::nullopt,
+        nothingAssetQuoteRequest != nullptr ? std::make_optional(nothingAssetQuoteRequest->toCpp()) : std::nullopt,
+        otherAssetQuoteRequest != nullptr ? std::make_optional(otherAssetQuoteRequest->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<JTradeAssetQuoteRequest::javaobject> fromCpp(const TradeAssetQuoteRequest& value) {
+      using JSignature = JTradeAssetQuoteRequest(jni::alias_ref<JFiatAssetQuoteRequest>, jni::alias_ref<JCryptoAssetQuoteRequest>, jni::alias_ref<JStockAssetQuoteRequest>, jni::alias_ref<JTransportAssetQuoteRequest>, jni::alias_ref<JEventAssetQuoteRequest>, jni::alias_ref<JNothingAssetQuoteRequest>, jni::alias_ref<JOtherAssetQuoteRequest>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.fiatAssetQuoteRequest.has_value() ? JFiatAssetQuoteRequest::fromCpp(value.fiatAssetQuoteRequest.value()) : nullptr,
+        value.cryptoAssetQuoteRequest.has_value() ? JCryptoAssetQuoteRequest::fromCpp(value.cryptoAssetQuoteRequest.value()) : nullptr,
+        value.stockAssetQuoteRequest.has_value() ? JStockAssetQuoteRequest::fromCpp(value.stockAssetQuoteRequest.value()) : nullptr,
+        value.transportAssetQuoteRequest.has_value() ? JTransportAssetQuoteRequest::fromCpp(value.transportAssetQuoteRequest.value()) : nullptr,
+        value.eventAssetQuoteRequest.has_value() ? JEventAssetQuoteRequest::fromCpp(value.eventAssetQuoteRequest.value()) : nullptr,
+        value.nothingAssetQuoteRequest.has_value() ? JNothingAssetQuoteRequest::fromCpp(value.nothingAssetQuoteRequest.value()) : nullptr,
+        value.otherAssetQuoteRequest.has_value() ? JOtherAssetQuoteRequest::fromCpp(value.otherAssetQuoteRequest.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,96 @@
+///
+/// JTradeAssetRef.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 "TradeAssetRef.hpp"
+
+#include "CryptoAssetRef.hpp"
+#include "EventAssetRef.hpp"
+#include "FiatAssetRef.hpp"
+#include "JCryptoAssetRef.hpp"
+#include "JEventAssetRef.hpp"
+#include "JFiatAssetRef.hpp"
+#include "JNothingAssetRef.hpp"
+#include "JOtherAssetRef.hpp"
+#include "JStockAssetRef.hpp"
+#include "JTransportAssetRef.hpp"
+#include "NothingAssetRef.hpp"
+#include "OtherAssetRef.hpp"
+#include "StockAssetRef.hpp"
+#include "TransportAssetRef.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "TradeAssetRef" and the the Kotlin data class "TradeAssetRef".
+   */
+  struct JTradeAssetRef final: public jni::JavaClass<JTradeAssetRef> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/TradeAssetRef;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct TradeAssetRef by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    TradeAssetRef toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldFiatAssetRef = clazz->getField<JFiatAssetRef>("fiatAssetRef");
+      jni::local_ref<JFiatAssetRef> fiatAssetRef = this->getFieldValue(fieldFiatAssetRef);
+      static const auto fieldCryptoAssetRef = clazz->getField<JCryptoAssetRef>("cryptoAssetRef");
+      jni::local_ref<JCryptoAssetRef> cryptoAssetRef = this->getFieldValue(fieldCryptoAssetRef);
+      static const auto fieldStockAssetRef = clazz->getField<JStockAssetRef>("stockAssetRef");
+      jni::local_ref<JStockAssetRef> stockAssetRef = this->getFieldValue(fieldStockAssetRef);
+      static const auto fieldTransportAssetRef = clazz->getField<JTransportAssetRef>("transportAssetRef");
+      jni::local_ref<JTransportAssetRef> transportAssetRef = this->getFieldValue(fieldTransportAssetRef);
+      static const auto fieldEventAssetRef = clazz->getField<JEventAssetRef>("eventAssetRef");
+      jni::local_ref<JEventAssetRef> eventAssetRef = this->getFieldValue(fieldEventAssetRef);
+      static const auto fieldOtherAssetRef = clazz->getField<JOtherAssetRef>("otherAssetRef");
+      jni::local_ref<JOtherAssetRef> otherAssetRef = this->getFieldValue(fieldOtherAssetRef);
+      static const auto fieldNothingAssetRef = clazz->getField<JNothingAssetRef>("nothingAssetRef");
+      jni::local_ref<JNothingAssetRef> nothingAssetRef = this->getFieldValue(fieldNothingAssetRef);
+      return TradeAssetRef(
+        fiatAssetRef != nullptr ? std::make_optional(fiatAssetRef->toCpp()) : std::nullopt,
+        cryptoAssetRef != nullptr ? std::make_optional(cryptoAssetRef->toCpp()) : std::nullopt,
+        stockAssetRef != nullptr ? std::make_optional(stockAssetRef->toCpp()) : std::nullopt,
+        transportAssetRef != nullptr ? std::make_optional(transportAssetRef->toCpp()) : std::nullopt,
+        eventAssetRef != nullptr ? std::make_optional(eventAssetRef->toCpp()) : std::nullopt,
+        otherAssetRef != nullptr ? std::make_optional(otherAssetRef->toCpp()) : std::nullopt,
+        nothingAssetRef != nullptr ? std::make_optional(nothingAssetRef->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<JTradeAssetRef::javaobject> fromCpp(const TradeAssetRef& value) {
+      using JSignature = JTradeAssetRef(jni::alias_ref<JFiatAssetRef>, jni::alias_ref<JCryptoAssetRef>, jni::alias_ref<JStockAssetRef>, jni::alias_ref<JTransportAssetRef>, jni::alias_ref<JEventAssetRef>, jni::alias_ref<JOtherAssetRef>, jni::alias_ref<JNothingAssetRef>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.fiatAssetRef.has_value() ? JFiatAssetRef::fromCpp(value.fiatAssetRef.value()) : nullptr,
+        value.cryptoAssetRef.has_value() ? JCryptoAssetRef::fromCpp(value.cryptoAssetRef.value()) : nullptr,
+        value.stockAssetRef.has_value() ? JStockAssetRef::fromCpp(value.stockAssetRef.value()) : nullptr,
+        value.transportAssetRef.has_value() ? JTransportAssetRef::fromCpp(value.transportAssetRef.value()) : nullptr,
+        value.eventAssetRef.has_value() ? JEventAssetRef::fromCpp(value.eventAssetRef.value()) : nullptr,
+        value.otherAssetRef.has_value() ? JOtherAssetRef::fromCpp(value.otherAssetRef.value()) : nullptr,
+        value.nothingAssetRef.has_value() ? JNothingAssetRef::fromCpp(value.nothingAssetRef.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,98 @@
+///
+/// JTradeExecutionResult.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 "TradeExecutionResult.hpp"
+
+#include "Address.hpp"
+#include "Coordinates.hpp"
+#include "Counterparty.hpp"
+#include "CryptoAsset.hpp"
+#include "EventAsset.hpp"
+#include "FiatAsset.hpp"
+#include "JAddress.hpp"
+#include "JCoordinates.hpp"
+#include "JCounterparty.hpp"
+#include "JCryptoAsset.hpp"
+#include "JEventAsset.hpp"
+#include "JFiatAsset.hpp"
+#include "JMerchantCounterparty.hpp"
+#include "JMerchantLocation.hpp"
+#include "JNothingAsset.hpp"
+#include "JOtherAsset.hpp"
+#include "JService.hpp"
+#include "JServiceCounterparty.hpp"
+#include "JStockAsset.hpp"
+#include "JTrade.hpp"
+#include "JTradeAsset.hpp"
+#include "JTradeState.hpp"
+#include "JTransportAsset.hpp"
+#include "JUserCounterparty.hpp"
+#include "MerchantCounterparty.hpp"
+#include "MerchantLocation.hpp"
+#include "NothingAsset.hpp"
+#include "OtherAsset.hpp"
+#include "Service.hpp"
+#include "ServiceCounterparty.hpp"
+#include "StockAsset.hpp"
+#include "Trade.hpp"
+#include "TradeAsset.hpp"
+#include "TradeState.hpp"
+#include "TransportAsset.hpp"
+#include "UserCounterparty.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "TradeExecutionResult" and the the Kotlin data class "TradeExecutionResult".
+   */
+  struct JTradeExecutionResult final: public jni::JavaClass<JTradeExecutionResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/TradeExecutionResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct TradeExecutionResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    TradeExecutionResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTrade = clazz->getField<JTrade>("trade");
+      jni::local_ref<JTrade> trade = this->getFieldValue(fieldTrade);
+      static const auto fieldError = clazz->getField<jni::JString>("error");
+      jni::local_ref<jni::JString> error = this->getFieldValue(fieldError);
+      return TradeExecutionResult(
+        trade != nullptr ? std::make_optional(trade->toCpp()) : std::nullopt,
+        error != nullptr ? std::make_optional(error->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<JTradeExecutionResult::javaobject> fromCpp(const TradeExecutionResult& value) {
+      using JSignature = JTradeExecutionResult(jni::alias_ref<JTrade>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.trade.has_value() ? JTrade::fromCpp(value.trade.value()) : nullptr,
+        value.error.has_value() ? jni::make_jstring(value.error.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::rncandle