react-native-candle 1.0.1 → 19.0.6-beta

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

@@ -0,0 +1,559 @@
+///
+/// JHybridRNCandleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridRNCandleSpec.hpp"
+
+// Forward declaration of `LinkedAccount` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct LinkedAccount; }
+// Forward declaration of `Service` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class Service; }
+// Forward declaration of `LinkedAccountDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct LinkedAccountDetails; }
+// Forward declaration of `ActiveLinkedAccountDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct ActiveLinkedAccountDetails; }
+// Forward declaration of `InactiveLinkedAccountDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct InactiveLinkedAccountDetails; }
+// Forward declaration of `UnavailableLinkedAccountDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct UnavailableLinkedAccountDetails; }
+// Forward declaration of `AssetAccountsResponse` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct AssetAccountsResponse; }
+// Forward declaration of `LinkedAccountStatusRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct LinkedAccountStatusRef; }
+// Forward declaration of `LinkedAccountState` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class LinkedAccountState; }
+// Forward declaration of `AssetAccount` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct AssetAccount; }
+// Forward declaration of `FiatAccount` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FiatAccount; }
+// Forward declaration of `FinancialAccountKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class FinancialAccountKind; }
+// Forward declaration of `ACHDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct ACHDetails; }
+// Forward declaration of `ACHAccountKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class ACHAccountKind; }
+// Forward declaration of `WireDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct WireDetails; }
+// Forward declaration of `CryptoAccount` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct CryptoAccount; }
+// Forward declaration of `StockAccount` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct StockAccount; }
+// Forward declaration of `TransportAccount` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TransportAccount; }
+// Forward declaration of `TransportAccountKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class TransportAccountKind; }
+// Forward declaration of `TradesResponse` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradesResponse; }
+// Forward declaration of `Trade` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Trade; }
+// Forward declaration of `TradeState` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class TradeState; }
+// Forward declaration of `Counterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Counterparty; }
+// Forward declaration of `MerchantCounterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MerchantCounterparty; }
+// Forward declaration of `MerchantLocation` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MerchantLocation; }
+// Forward declaration of `UserCounterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct UserCounterparty; }
+// Forward declaration of `ServiceCounterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct ServiceCounterparty; }
+// Forward declaration of `TradeAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeAsset; }
+// Forward declaration of `FiatAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FiatAsset; }
+// Forward declaration of `CryptoAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct CryptoAsset; }
+// Forward declaration of `StockAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct StockAsset; }
+// Forward declaration of `TransportAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TransportAsset; }
+// Forward declaration of `Coordinates` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Coordinates; }
+// Forward declaration of `Address` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Address; }
+// Forward declaration of `EventAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct EventAsset; }
+// Forward declaration of `OtherAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct OtherAsset; }
+// Forward declaration of `NothingAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct NothingAsset; }
+// Forward declaration of `TradeQuotesResponse` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeQuotesResponse; }
+// Forward declaration of `TradeQuote` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeQuote; }
+// Forward declaration of `PresentationBackground` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class PresentationBackground; }
+// Forward declaration of `PresentationStyle` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class PresentationStyle; }
+// Forward declaration of `TradeExecutionResult` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeExecutionResult; }
+// Forward declaration of `LinkedAccountRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct LinkedAccountRef; }
+// Forward declaration of `AssetAccountsQuery` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct AssetAccountsQuery; }
+// Forward declaration of `AssetAccountKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class AssetAccountKind; }
+// Forward declaration of `AssetAccountRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct AssetAccountRef; }
+// Forward declaration of `TradesQuery` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradesQuery; }
+// Forward declaration of `TradeAssetKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class TradeAssetKind; }
+// Forward declaration of `CounterpartyKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class CounterpartyKind; }
+// Forward declaration of `TradeRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeRef; }
+// Forward declaration of `TradeAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeAssetRef; }
+// Forward declaration of `FiatAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FiatAssetRef; }
+// Forward declaration of `CryptoAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct CryptoAssetRef; }
+// Forward declaration of `StockAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct StockAssetRef; }
+// Forward declaration of `TransportAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TransportAssetRef; }
+// Forward declaration of `EventAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct EventAssetRef; }
+// Forward declaration of `OtherAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct OtherAssetRef; }
+// Forward declaration of `NothingAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct NothingAssetRef; }
+// Forward declaration of `TradeQuotesRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeQuotesRequest; }
+// Forward declaration of `TradeAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeAssetQuoteRequest; }
+// Forward declaration of `FiatAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FiatAssetQuoteRequest; }
+// Forward declaration of `CryptoAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct CryptoAssetQuoteRequest; }
+// Forward declaration of `StockAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct StockAssetQuoteRequest; }
+// Forward declaration of `TransportAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TransportAssetQuoteRequest; }
+// Forward declaration of `EventAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct EventAssetQuoteRequest; }
+// Forward declaration of `NothingAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct NothingAssetQuoteRequest; }
+// Forward declaration of `OtherAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct OtherAssetQuoteRequest; }
+// Forward declaration of `CounterpartyQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct CounterpartyQuoteRequest; }
+// Forward declaration of `UserCounterpartyQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct UserCounterpartyQuoteRequest; }
+// Forward declaration of `MerchantCounterpartyQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MerchantCounterpartyQuoteRequest; }
+// Forward declaration of `ServiceCounterpartyQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct ServiceCounterpartyQuoteRequest; }
+
+#include "LinkedAccount.hpp"
+#include <vector>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JLinkedAccount.hpp"
+#include <string>
+#include "Service.hpp"
+#include "JService.hpp"
+#include "LinkedAccountDetails.hpp"
+#include "JLinkedAccountDetails.hpp"
+#include "ActiveLinkedAccountDetails.hpp"
+#include <optional>
+#include "JActiveLinkedAccountDetails.hpp"
+#include "InactiveLinkedAccountDetails.hpp"
+#include "JInactiveLinkedAccountDetails.hpp"
+#include "UnavailableLinkedAccountDetails.hpp"
+#include "JUnavailableLinkedAccountDetails.hpp"
+#include <NitroModules/JUnit.hpp>
+#include "AssetAccountsResponse.hpp"
+#include "JAssetAccountsResponse.hpp"
+#include "LinkedAccountStatusRef.hpp"
+#include "JLinkedAccountStatusRef.hpp"
+#include "LinkedAccountState.hpp"
+#include "JLinkedAccountState.hpp"
+#include "AssetAccount.hpp"
+#include "JAssetAccount.hpp"
+#include "FiatAccount.hpp"
+#include "JFiatAccount.hpp"
+#include "FinancialAccountKind.hpp"
+#include "JFinancialAccountKind.hpp"
+#include "ACHDetails.hpp"
+#include "JACHDetails.hpp"
+#include "ACHAccountKind.hpp"
+#include "JACHAccountKind.hpp"
+#include "WireDetails.hpp"
+#include "JWireDetails.hpp"
+#include "CryptoAccount.hpp"
+#include "JCryptoAccount.hpp"
+#include "StockAccount.hpp"
+#include "JStockAccount.hpp"
+#include "TransportAccount.hpp"
+#include "JTransportAccount.hpp"
+#include "TransportAccountKind.hpp"
+#include "JTransportAccountKind.hpp"
+#include "TradesResponse.hpp"
+#include "JTradesResponse.hpp"
+#include "Trade.hpp"
+#include "JTrade.hpp"
+#include "TradeState.hpp"
+#include "JTradeState.hpp"
+#include "Counterparty.hpp"
+#include "JCounterparty.hpp"
+#include "MerchantCounterparty.hpp"
+#include "JMerchantCounterparty.hpp"
+#include "MerchantLocation.hpp"
+#include "JMerchantLocation.hpp"
+#include "UserCounterparty.hpp"
+#include "JUserCounterparty.hpp"
+#include "ServiceCounterparty.hpp"
+#include "JServiceCounterparty.hpp"
+#include "TradeAsset.hpp"
+#include "JTradeAsset.hpp"
+#include "FiatAsset.hpp"
+#include "JFiatAsset.hpp"
+#include "CryptoAsset.hpp"
+#include "JCryptoAsset.hpp"
+#include "StockAsset.hpp"
+#include "JStockAsset.hpp"
+#include "TransportAsset.hpp"
+#include "JTransportAsset.hpp"
+#include "Coordinates.hpp"
+#include "JCoordinates.hpp"
+#include "Address.hpp"
+#include "JAddress.hpp"
+#include "EventAsset.hpp"
+#include "JEventAsset.hpp"
+#include "OtherAsset.hpp"
+#include "JOtherAsset.hpp"
+#include "NothingAsset.hpp"
+#include "JNothingAsset.hpp"
+#include "TradeQuotesResponse.hpp"
+#include "JTradeQuotesResponse.hpp"
+#include "TradeQuote.hpp"
+#include "JTradeQuote.hpp"
+#include "PresentationBackground.hpp"
+#include "JPresentationBackground.hpp"
+#include "PresentationStyle.hpp"
+#include "JPresentationStyle.hpp"
+#include <functional>
+#include "JFunc_void_LinkedAccount.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "TradeExecutionResult.hpp"
+#include "JFunc_void_TradeExecutionResult.hpp"
+#include "JTradeExecutionResult.hpp"
+#include "LinkedAccountRef.hpp"
+#include "JLinkedAccountRef.hpp"
+#include "AssetAccountsQuery.hpp"
+#include "JAssetAccountsQuery.hpp"
+#include "AssetAccountKind.hpp"
+#include "JAssetAccountKind.hpp"
+#include "AssetAccountRef.hpp"
+#include "JAssetAccountRef.hpp"
+#include "TradesQuery.hpp"
+#include "JTradesQuery.hpp"
+#include "TradeAssetKind.hpp"
+#include "JTradeAssetKind.hpp"
+#include "CounterpartyKind.hpp"
+#include "JCounterpartyKind.hpp"
+#include "TradeRef.hpp"
+#include "JTradeRef.hpp"
+#include "TradeAssetRef.hpp"
+#include "JTradeAssetRef.hpp"
+#include "FiatAssetRef.hpp"
+#include "JFiatAssetRef.hpp"
+#include "CryptoAssetRef.hpp"
+#include "JCryptoAssetRef.hpp"
+#include "StockAssetRef.hpp"
+#include "JStockAssetRef.hpp"
+#include "TransportAssetRef.hpp"
+#include "JTransportAssetRef.hpp"
+#include "EventAssetRef.hpp"
+#include "JEventAssetRef.hpp"
+#include "OtherAssetRef.hpp"
+#include "JOtherAssetRef.hpp"
+#include "NothingAssetRef.hpp"
+#include "JNothingAssetRef.hpp"
+#include "TradeQuotesRequest.hpp"
+#include "JTradeQuotesRequest.hpp"
+#include "TradeAssetQuoteRequest.hpp"
+#include "JTradeAssetQuoteRequest.hpp"
+#include "FiatAssetQuoteRequest.hpp"
+#include "JFiatAssetQuoteRequest.hpp"
+#include "CryptoAssetQuoteRequest.hpp"
+#include "JCryptoAssetQuoteRequest.hpp"
+#include "StockAssetQuoteRequest.hpp"
+#include "JStockAssetQuoteRequest.hpp"
+#include "TransportAssetQuoteRequest.hpp"
+#include "JTransportAssetQuoteRequest.hpp"
+#include "EventAssetQuoteRequest.hpp"
+#include "JEventAssetQuoteRequest.hpp"
+#include "NothingAssetQuoteRequest.hpp"
+#include "JNothingAssetQuoteRequest.hpp"
+#include "OtherAssetQuoteRequest.hpp"
+#include "JOtherAssetQuoteRequest.hpp"
+#include "CounterpartyQuoteRequest.hpp"
+#include "JCounterpartyQuoteRequest.hpp"
+#include "UserCounterpartyQuoteRequest.hpp"
+#include "JUserCounterpartyQuoteRequest.hpp"
+#include "MerchantCounterpartyQuoteRequest.hpp"
+#include "JMerchantCounterpartyQuoteRequest.hpp"
+#include "ServiceCounterpartyQuoteRequest.hpp"
+#include "JServiceCounterpartyQuoteRequest.hpp"
+
+namespace margelo::nitro::rncandle {
+
+  std::shared_ptr<JHybridRNCandleSpec> JHybridRNCandleSpec::JavaPart::getJHybridRNCandleSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridRNCandleSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridRNCandleSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridRNCandleSpec::CxxPart::jhybriddata> JHybridRNCandleSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridRNCandleSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridRNCandleSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridRNCandleSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridRNCandleSpec>(castJavaPart);
+  }
+
+  void JHybridRNCandleSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridRNCandleSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridRNCandleSpec::candleLinkSheet(bool isPresented, const std::optional<std::vector<Service>>& services, double cornerRadius, const std::optional<std::string>& customerName, bool showDynamicLoading, PresentationBackground presentationBackground, PresentationStyle presentationStyle, const std::function<void(const LinkedAccount& /* account */)>& onSuccess) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* isPresented */, jni::alias_ref<jni::JArrayClass<JService>> /* services */, double /* cornerRadius */, jni::alias_ref<jni::JString> /* customerName */, jboolean /* showDynamicLoading */, jni::alias_ref<JPresentationBackground> /* presentationBackground */, jni::alias_ref<JPresentationStyle> /* presentationStyle */, jni::alias_ref<JFunc_void_LinkedAccount::javaobject> /* onSuccess */)>("candleLinkSheet_cxx");
+    method(_javaPart, isPresented, services.has_value() ? [&]() {
+      size_t __size = services.value().size();
+      jni::local_ref<jni::JArrayClass<JService>> __array = jni::JArrayClass<JService>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = services.value()[__i];
+        auto __elementJni = JService::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }() : nullptr, cornerRadius, customerName.has_value() ? jni::make_jstring(customerName.value()) : nullptr, showDynamicLoading, JPresentationBackground::fromCpp(presentationBackground), JPresentationStyle::fromCpp(presentationStyle), JFunc_void_LinkedAccount_cxx::fromCpp(onSuccess));
+  }
+  void JHybridRNCandleSpec::candleTradeExecutionSheet(const TradeQuote& tradeQuote, PresentationBackground presentationBackground, const std::function<void(const TradeExecutionResult& /* result */)>& completion) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JTradeQuote> /* tradeQuote */, jni::alias_ref<JPresentationBackground> /* presentationBackground */, jni::alias_ref<JFunc_void_TradeExecutionResult::javaobject> /* completion */)>("candleTradeExecutionSheet_cxx");
+    method(_javaPart, JTradeQuote::fromCpp(tradeQuote), JPresentationBackground::fromCpp(presentationBackground), JFunc_void_TradeExecutionResult_cxx::fromCpp(completion));
+  }
+  void JHybridRNCandleSpec::initialize(const std::string& appKey, const std::string& appSecret, const std::optional<std::string>& accessGroup) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* appKey */, jni::alias_ref<jni::JString> /* appSecret */, jni::alias_ref<jni::JString> /* accessGroup */)>("initialize");
+    method(_javaPart, jni::make_jstring(appKey), jni::make_jstring(appSecret), accessGroup.has_value() ? jni::make_jstring(accessGroup.value()) : nullptr);
+  }
+  std::shared_ptr<Promise<std::vector<LinkedAccount>>> JHybridRNCandleSpec::getLinkedAccounts() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getLinkedAccounts");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::vector<LinkedAccount>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JArrayClass<JLinkedAccount>>(__boxedResult);
+        __promise->resolve([&]() {
+          size_t __size = __result->size();
+          std::vector<LinkedAccount> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __result->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<LinkedAccount>> JHybridRNCandleSpec::getLinkedAccount(const LinkedAccountRef& ref) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JLinkedAccountRef> /* ref */)>("getLinkedAccount");
+    auto __result = method(_javaPart, JLinkedAccountRef::fromCpp(ref));
+    return [&]() {
+      auto __promise = Promise<LinkedAccount>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JLinkedAccount>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridRNCandleSpec::unlinkAccount(const LinkedAccountRef& ref) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JLinkedAccountRef> /* ref */)>("unlinkAccount");
+    auto __result = method(_javaPart, JLinkedAccountRef::fromCpp(ref));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<AssetAccountsResponse>> JHybridRNCandleSpec::getAssetAccounts(const AssetAccountsQuery& query) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JAssetAccountsQuery> /* query */)>("getAssetAccounts");
+    auto __result = method(_javaPart, JAssetAccountsQuery::fromCpp(query));
+    return [&]() {
+      auto __promise = Promise<AssetAccountsResponse>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JAssetAccountsResponse>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<AssetAccount>> JHybridRNCandleSpec::getAssetAccount(const AssetAccountRef& ref) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JAssetAccountRef> /* ref */)>("getAssetAccount");
+    auto __result = method(_javaPart, JAssetAccountRef::fromCpp(ref));
+    return [&]() {
+      auto __promise = Promise<AssetAccount>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JAssetAccount>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<TradesResponse>> JHybridRNCandleSpec::getTrades(const TradesQuery& query) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JTradesQuery> /* query */)>("getTrades");
+    auto __result = method(_javaPart, JTradesQuery::fromCpp(query));
+    return [&]() {
+      auto __promise = Promise<TradesResponse>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JTradesResponse>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<Trade>> JHybridRNCandleSpec::getTrade(const TradeRef& ref) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JTradeRef> /* ref */)>("getTrade");
+    auto __result = method(_javaPart, JTradeRef::fromCpp(ref));
+    return [&]() {
+      auto __promise = Promise<Trade>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JTrade>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<Trade>> JHybridRNCandleSpec::cancelTrade(const TradeRef& ref) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JTradeRef> /* ref */)>("cancelTrade");
+    auto __result = method(_javaPart, JTradeRef::fromCpp(ref));
+    return [&]() {
+      auto __promise = Promise<Trade>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JTrade>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<TradeQuotesResponse>> JHybridRNCandleSpec::getTradeQuotes(const TradeQuotesRequest& request) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JTradeQuotesRequest> /* request */)>("getTradeQuotes");
+    auto __result = method(_javaPart, JTradeQuotesRequest::fromCpp(request));
+    return [&]() {
+      auto __promise = Promise<TradeQuotesResponse>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JTradeQuotesResponse>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<Trade>> JHybridRNCandleSpec::executeTrade(const TradeQuote& quote) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JTradeQuote> /* quote */)>("executeTrade");
+    auto __result = method(_javaPart, JTradeQuote::fromCpp(quote));
+    return [&]() {
+      auto __promise = Promise<Trade>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JTrade>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridRNCandleSpec::createUser(const std::string& appUserID) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* appUserID */)>("createUser");
+    auto __result = method(_javaPart, jni::make_jstring(appUserID));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridRNCandleSpec::deleteUser() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("deleteUser");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::rncandle

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

@@ -0,0 +1,77 @@
+///
+/// HybridRNCandleSpec.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 "HybridRNCandleSpec.hpp"
+
+
+
+
+namespace margelo::nitro::rncandle {
+
+  using namespace facebook;
+
+  class JHybridRNCandleSpec: public virtual HybridRNCandleSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/HybridRNCandleSpec;";
+      std::shared_ptr<JHybridRNCandleSpec> getJHybridRNCandleSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/rncandle/HybridRNCandleSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridRNCandleSpec(const jni::local_ref<JHybridRNCandleSpec::JavaPart>& javaPart):
+      HybridObject(HybridRNCandleSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridRNCandleSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridRNCandleSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void candleLinkSheet(bool isPresented, const std::optional<std::vector<Service>>& services, double cornerRadius, const std::optional<std::string>& customerName, bool showDynamicLoading, PresentationBackground presentationBackground, PresentationStyle presentationStyle, const std::function<void(const LinkedAccount& /* account */)>& onSuccess) override;
+    void candleTradeExecutionSheet(const TradeQuote& tradeQuote, PresentationBackground presentationBackground, const std::function<void(const TradeExecutionResult& /* result */)>& completion) override;
+    void initialize(const std::string& appKey, const std::string& appSecret, const std::optional<std::string>& accessGroup) override;
+    std::shared_ptr<Promise<std::vector<LinkedAccount>>> getLinkedAccounts() override;
+    std::shared_ptr<Promise<LinkedAccount>> getLinkedAccount(const LinkedAccountRef& ref) override;
+    std::shared_ptr<Promise<void>> unlinkAccount(const LinkedAccountRef& ref) override;
+    std::shared_ptr<Promise<AssetAccountsResponse>> getAssetAccounts(const AssetAccountsQuery& query) override;
+    std::shared_ptr<Promise<AssetAccount>> getAssetAccount(const AssetAccountRef& ref) override;
+    std::shared_ptr<Promise<TradesResponse>> getTrades(const TradesQuery& query) override;
+    std::shared_ptr<Promise<Trade>> getTrade(const TradeRef& ref) override;
+    std::shared_ptr<Promise<Trade>> cancelTrade(const TradeRef& ref) override;
+    std::shared_ptr<Promise<TradeQuotesResponse>> getTradeQuotes(const TradeQuotesRequest& request) override;
+    std::shared_ptr<Promise<Trade>> executeTrade(const TradeQuote& quote) override;
+    std::shared_ptr<Promise<void>> createUser(const std::string& appUserID) override;
+    std::shared_ptr<Promise<void>> deleteUser() override;
+
+  private:
+    jni::global_ref<JHybridRNCandleSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::rncandle