react-native-candle 0.1.19 → 0.1.21

package/nitrogen/generated/ios/ReactNativeCandle-Swift-Cxx-Bridge.hpp

@@ -32,6 +32,8 @@ namespace margelo::nitro::rncandle { struct Counterparty; }
 namespace margelo::nitro::rncandle { struct FiatAccountDetails; }
 // Forward declaration of `FiatAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct FiatAssetQuoteRequest; }
+// Forward declaration of `FiatAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FiatAssetRef; }
 // Forward declaration of `FiatAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct FiatAsset; }
 // Forward declaration of `HybridRNCandleSpec` to properly resolve imports.
@@ -48,6 +50,8 @@ namespace margelo::nitro::rncandle { struct LinkedAccount; }
 namespace margelo::nitro::rncandle { struct MarketAccountDetails; }
 // Forward declaration of `MarketAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct MarketAssetQuoteRequest; }
+// Forward declaration of `MarketTradeAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MarketTradeAssetRef; }
 // Forward declaration of `MarketTradeAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct MarketTradeAsset; }
 // Forward declaration of `MerchantCounterparty` to properly resolve imports.
@@ -56,8 +60,12 @@ namespace margelo::nitro::rncandle { struct MerchantCounterparty; }
 namespace margelo::nitro::rncandle { struct MerchantLocation; }
 // Forward declaration of `NothingAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct NothingAssetQuoteRequest; }
+// Forward declaration of `NothingAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct NothingAssetRef; }
 // Forward declaration of `NothingAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct NothingAsset; }
+// Forward declaration of `OtherAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct OtherAssetRef; }
 // Forward declaration of `OtherAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct OtherAsset; }
 // Forward declaration of `ServiceCounterparty` to properly resolve imports.
@@ -66,6 +74,8 @@ namespace margelo::nitro::rncandle { struct ServiceCounterparty; }
 namespace margelo::nitro::rncandle { enum class Service; }
 // Forward declaration of `TradeAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeAsset; }
+// Forward declaration of `TradeExecutionResult` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeExecutionResult; }
 // Forward declaration of `TradeQuote` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuote; }
 // Forward declaration of `TradeState` to properly resolve imports.
@@ -74,6 +84,8 @@ namespace margelo::nitro::rncandle { enum class TradeState; }
 namespace margelo::nitro::rncandle { struct Trade; }
 // Forward declaration of `TransportAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TransportAssetQuoteRequest; }
+// Forward declaration of `TransportAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TransportAssetRef; }
 // Forward declaration of `TransportAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TransportAsset; }
 // Forward declaration of `UserCounterparty` to properly resolve imports.
@@ -98,6 +110,7 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include "FiatAccountDetails.hpp"
 #include "FiatAsset.hpp"
 #include "FiatAssetQuoteRequest.hpp"
+#include "FiatAssetRef.hpp"
 #include "HybridRNCandleSpec.hpp"
 #include "InactiveLinkedAccountDetails.hpp"
 #include "LegalAccountKind.hpp"
@@ -106,19 +119,24 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include "MarketAccountDetails.hpp"
 #include "MarketAssetQuoteRequest.hpp"
 #include "MarketTradeAsset.hpp"
+#include "MarketTradeAssetRef.hpp"
 #include "MerchantCounterparty.hpp"
 #include "MerchantLocation.hpp"
 #include "NothingAsset.hpp"
 #include "NothingAssetQuoteRequest.hpp"
+#include "NothingAssetRef.hpp"
 #include "OtherAsset.hpp"
+#include "OtherAssetRef.hpp"
 #include "Service.hpp"
 #include "ServiceCounterparty.hpp"
 #include "Trade.hpp"
 #include "TradeAsset.hpp"
+#include "TradeExecutionResult.hpp"
 #include "TradeQuote.hpp"
 #include "TradeState.hpp"
 #include "TransportAsset.hpp"
 #include "TransportAssetQuoteRequest.hpp"
+#include "TransportAssetRef.hpp"
 #include "UserCounterparty.hpp"
 #include "WireDetails.hpp"
 #include <NitroModules/AnyMap.hpp>
@@ -207,6 +225,118 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Func_void_LinkedAccount_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<FiatAsset>
+  /**
+   * Specialized version of `std::optional<FiatAsset>`.
+   */
+  using std__optional_FiatAsset_ = std::optional<FiatAsset>;
+  inline std::optional<FiatAsset> create_std__optional_FiatAsset_(const FiatAsset& value) {
+    return std::optional<FiatAsset>(value);
+  }
+  
+  // pragma MARK: std::optional<MarketTradeAsset>
+  /**
+   * Specialized version of `std::optional<MarketTradeAsset>`.
+   */
+  using std__optional_MarketTradeAsset_ = std::optional<MarketTradeAsset>;
+  inline std::optional<MarketTradeAsset> create_std__optional_MarketTradeAsset_(const MarketTradeAsset& value) {
+    return std::optional<MarketTradeAsset>(value);
+  }
+  
+  // pragma MARK: std::optional<TransportAsset>
+  /**
+   * Specialized version of `std::optional<TransportAsset>`.
+   */
+  using std__optional_TransportAsset_ = std::optional<TransportAsset>;
+  inline std::optional<TransportAsset> create_std__optional_TransportAsset_(const TransportAsset& value) {
+    return std::optional<TransportAsset>(value);
+  }
+  
+  // pragma MARK: std::optional<OtherAsset>
+  /**
+   * Specialized version of `std::optional<OtherAsset>`.
+   */
+  using std__optional_OtherAsset_ = std::optional<OtherAsset>;
+  inline std::optional<OtherAsset> create_std__optional_OtherAsset_(const OtherAsset& value) {
+    return std::optional<OtherAsset>(value);
+  }
+  
+  // pragma MARK: std::optional<NothingAsset>
+  /**
+   * Specialized version of `std::optional<NothingAsset>`.
+   */
+  using std__optional_NothingAsset_ = std::optional<NothingAsset>;
+  inline std::optional<NothingAsset> create_std__optional_NothingAsset_(const NothingAsset& value) {
+    return std::optional<NothingAsset>(value);
+  }
+  
+  // pragma MARK: std::optional<MerchantLocation>
+  /**
+   * Specialized version of `std::optional<MerchantLocation>`.
+   */
+  using std__optional_MerchantLocation_ = std::optional<MerchantLocation>;
+  inline std::optional<MerchantLocation> create_std__optional_MerchantLocation_(const MerchantLocation& value) {
+    return std::optional<MerchantLocation>(value);
+  }
+  
+  // pragma MARK: std::optional<MerchantCounterparty>
+  /**
+   * Specialized version of `std::optional<MerchantCounterparty>`.
+   */
+  using std__optional_MerchantCounterparty_ = std::optional<MerchantCounterparty>;
+  inline std::optional<MerchantCounterparty> create_std__optional_MerchantCounterparty_(const MerchantCounterparty& value) {
+    return std::optional<MerchantCounterparty>(value);
+  }
+  
+  // pragma MARK: std::optional<UserCounterparty>
+  /**
+   * Specialized version of `std::optional<UserCounterparty>`.
+   */
+  using std__optional_UserCounterparty_ = std::optional<UserCounterparty>;
+  inline std::optional<UserCounterparty> create_std__optional_UserCounterparty_(const UserCounterparty& value) {
+    return std::optional<UserCounterparty>(value);
+  }
+  
+  // pragma MARK: std::optional<ServiceCounterparty>
+  /**
+   * Specialized version of `std::optional<ServiceCounterparty>`.
+   */
+  using std__optional_ServiceCounterparty_ = std::optional<ServiceCounterparty>;
+  inline std::optional<ServiceCounterparty> create_std__optional_ServiceCounterparty_(const ServiceCounterparty& value) {
+    return std::optional<ServiceCounterparty>(value);
+  }
+  
+  // pragma MARK: std::optional<Trade>
+  /**
+   * Specialized version of `std::optional<Trade>`.
+   */
+  using std__optional_Trade_ = std::optional<Trade>;
+  inline std::optional<Trade> create_std__optional_Trade_(const Trade& value) {
+    return std::optional<Trade>(value);
+  }
+  
+  // pragma MARK: std::function<void(const TradeExecutionResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const TradeExecutionResult&)>`.
+   */
+  using Func_void_TradeExecutionResult = std::function<void(const TradeExecutionResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const TradeExecutionResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_TradeExecutionResult_Wrapper final {
+  public:
+    explicit Func_void_TradeExecutionResult_Wrapper(std::function<void(const TradeExecutionResult& /* result */)>&& func): _function(std::make_shared<std::function<void(const TradeExecutionResult& /* result */)>>(std::move(func))) {}
+    inline void call(TradeExecutionResult result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const TradeExecutionResult& /* result */)>> _function;
+  };
+  Func_void_TradeExecutionResult create_Func_void_TradeExecutionResult(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_TradeExecutionResult_Wrapper wrap_Func_void_TradeExecutionResult(Func_void_TradeExecutionResult value) {
+    return Func_void_TradeExecutionResult_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::vector<LinkedAccount>
   /**
    * Specialized version of `std::vector<LinkedAccount>`.
@@ -274,6 +404,18 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<LinkedAccount>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<LinkedAccount>>`.
+   */
+  using std__shared_ptr_Promise_LinkedAccount__ = std::shared_ptr<Promise<LinkedAccount>>;
+  inline std::shared_ptr<Promise<LinkedAccount>> create_std__shared_ptr_Promise_LinkedAccount__() {
+    return Promise<LinkedAccount>::create();
+  }
+  inline PromiseHolder<LinkedAccount> wrap_std__shared_ptr_Promise_LinkedAccount__(std::shared_ptr<Promise<LinkedAccount>> promise) {
+    return PromiseHolder<LinkedAccount>(std::move(promise));
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<void>>
   /**
    * Specialized version of `std::shared_ptr<Promise<void>>`.
@@ -407,85 +549,38 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return std::optional<AssetAccountKind>(value);
   }
   
-  // pragma MARK: std::optional<MerchantLocation>
-  /**
-   * Specialized version of `std::optional<MerchantLocation>`.
-   */
-  using std__optional_MerchantLocation_ = std::optional<MerchantLocation>;
-  inline std::optional<MerchantLocation> create_std__optional_MerchantLocation_(const MerchantLocation& value) {
-    return std::optional<MerchantLocation>(value);
-  }
-  
-  // pragma MARK: std::optional<MerchantCounterparty>
-  /**
-   * Specialized version of `std::optional<MerchantCounterparty>`.
-   */
-  using std__optional_MerchantCounterparty_ = std::optional<MerchantCounterparty>;
-  inline std::optional<MerchantCounterparty> create_std__optional_MerchantCounterparty_(const MerchantCounterparty& value) {
-    return std::optional<MerchantCounterparty>(value);
-  }
-  
-  // pragma MARK: std::optional<UserCounterparty>
-  /**
-   * Specialized version of `std::optional<UserCounterparty>`.
-   */
-  using std__optional_UserCounterparty_ = std::optional<UserCounterparty>;
-  inline std::optional<UserCounterparty> create_std__optional_UserCounterparty_(const UserCounterparty& value) {
-    return std::optional<UserCounterparty>(value);
-  }
-  
-  // pragma MARK: std::optional<ServiceCounterparty>
-  /**
-   * Specialized version of `std::optional<ServiceCounterparty>`.
-   */
-  using std__optional_ServiceCounterparty_ = std::optional<ServiceCounterparty>;
-  inline std::optional<ServiceCounterparty> create_std__optional_ServiceCounterparty_(const ServiceCounterparty& value) {
-    return std::optional<ServiceCounterparty>(value);
-  }
-  
-  // pragma MARK: std::optional<FiatAsset>
-  /**
-   * Specialized version of `std::optional<FiatAsset>`.
-   */
-  using std__optional_FiatAsset_ = std::optional<FiatAsset>;
-  inline std::optional<FiatAsset> create_std__optional_FiatAsset_(const FiatAsset& value) {
-    return std::optional<FiatAsset>(value);
-  }
-  
-  // pragma MARK: std::optional<MarketTradeAsset>
+  // pragma MARK: std::shared_ptr<Promise<AssetAccount>>
   /**
-   * Specialized version of `std::optional<MarketTradeAsset>`.
+   * Specialized version of `std::shared_ptr<Promise<AssetAccount>>`.
    */
-  using std__optional_MarketTradeAsset_ = std::optional<MarketTradeAsset>;
-  inline std::optional<MarketTradeAsset> create_std__optional_MarketTradeAsset_(const MarketTradeAsset& value) {
-    return std::optional<MarketTradeAsset>(value);
+  using std__shared_ptr_Promise_AssetAccount__ = std::shared_ptr<Promise<AssetAccount>>;
+  inline std::shared_ptr<Promise<AssetAccount>> create_std__shared_ptr_Promise_AssetAccount__() {
+    return Promise<AssetAccount>::create();
   }
-  
-  // pragma MARK: std::optional<TransportAsset>
-  /**
-   * Specialized version of `std::optional<TransportAsset>`.
-   */
-  using std__optional_TransportAsset_ = std::optional<TransportAsset>;
-  inline std::optional<TransportAsset> create_std__optional_TransportAsset_(const TransportAsset& value) {
-    return std::optional<TransportAsset>(value);
+  inline PromiseHolder<AssetAccount> wrap_std__shared_ptr_Promise_AssetAccount__(std::shared_ptr<Promise<AssetAccount>> promise) {
+    return PromiseHolder<AssetAccount>(std::move(promise));
   }
   
-  // pragma MARK: std::optional<OtherAsset>
+  // pragma MARK: std::function<void(const AssetAccount& /* result */)>
   /**
-   * Specialized version of `std::optional<OtherAsset>`.
+   * Specialized version of `std::function<void(const AssetAccount&)>`.
    */
-  using std__optional_OtherAsset_ = std::optional<OtherAsset>;
-  inline std::optional<OtherAsset> create_std__optional_OtherAsset_(const OtherAsset& value) {
-    return std::optional<OtherAsset>(value);
-  }
-  
-  // pragma MARK: std::optional<NothingAsset>
+  using Func_void_AssetAccount = std::function<void(const AssetAccount& /* result */)>;
   /**
-   * Specialized version of `std::optional<NothingAsset>`.
+   * Wrapper class for a `std::function<void(const AssetAccount& / * result * /)>`, this can be used from Swift.
    */
-  using std__optional_NothingAsset_ = std::optional<NothingAsset>;
-  inline std::optional<NothingAsset> create_std__optional_NothingAsset_(const NothingAsset& value) {
-    return std::optional<NothingAsset>(value);
+  class Func_void_AssetAccount_Wrapper final {
+  public:
+    explicit Func_void_AssetAccount_Wrapper(std::function<void(const AssetAccount& /* result */)>&& func): _function(std::make_shared<std::function<void(const AssetAccount& /* result */)>>(std::move(func))) {}
+    inline void call(AssetAccount result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const AssetAccount& /* result */)>> _function;
+  };
+  Func_void_AssetAccount create_Func_void_AssetAccount(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_AssetAccount_Wrapper wrap_Func_void_AssetAccount(Func_void_AssetAccount value) {
+    return Func_void_AssetAccount_Wrapper(std::move(value));
   }
   
   // pragma MARK: std::vector<Trade>
@@ -533,6 +628,85 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Func_void_std__vector_Trade__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<Trade>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<Trade>>`.
+   */
+  using std__shared_ptr_Promise_Trade__ = std::shared_ptr<Promise<Trade>>;
+  inline std::shared_ptr<Promise<Trade>> create_std__shared_ptr_Promise_Trade__() {
+    return Promise<Trade>::create();
+  }
+  inline PromiseHolder<Trade> wrap_std__shared_ptr_Promise_Trade__(std::shared_ptr<Promise<Trade>> promise) {
+    return PromiseHolder<Trade>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const Trade& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const Trade&)>`.
+   */
+  using Func_void_Trade = std::function<void(const Trade& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const Trade& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_Trade_Wrapper final {
+  public:
+    explicit Func_void_Trade_Wrapper(std::function<void(const Trade& /* result */)>&& func): _function(std::make_shared<std::function<void(const Trade& /* result */)>>(std::move(func))) {}
+    inline void call(Trade result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const Trade& /* result */)>> _function;
+  };
+  Func_void_Trade create_Func_void_Trade(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_Trade_Wrapper wrap_Func_void_Trade(Func_void_Trade value) {
+    return Func_void_Trade_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<FiatAssetRef>
+  /**
+   * Specialized version of `std::optional<FiatAssetRef>`.
+   */
+  using std__optional_FiatAssetRef_ = std::optional<FiatAssetRef>;
+  inline std::optional<FiatAssetRef> create_std__optional_FiatAssetRef_(const FiatAssetRef& value) {
+    return std::optional<FiatAssetRef>(value);
+  }
+  
+  // pragma MARK: std::optional<MarketTradeAssetRef>
+  /**
+   * Specialized version of `std::optional<MarketTradeAssetRef>`.
+   */
+  using std__optional_MarketTradeAssetRef_ = std::optional<MarketTradeAssetRef>;
+  inline std::optional<MarketTradeAssetRef> create_std__optional_MarketTradeAssetRef_(const MarketTradeAssetRef& value) {
+    return std::optional<MarketTradeAssetRef>(value);
+  }
+  
+  // pragma MARK: std::optional<TransportAssetRef>
+  /**
+   * Specialized version of `std::optional<TransportAssetRef>`.
+   */
+  using std__optional_TransportAssetRef_ = std::optional<TransportAssetRef>;
+  inline std::optional<TransportAssetRef> create_std__optional_TransportAssetRef_(const TransportAssetRef& value) {
+    return std::optional<TransportAssetRef>(value);
+  }
+  
+  // pragma MARK: std::optional<OtherAssetRef>
+  /**
+   * Specialized version of `std::optional<OtherAssetRef>`.
+   */
+  using std__optional_OtherAssetRef_ = std::optional<OtherAssetRef>;
+  inline std::optional<OtherAssetRef> create_std__optional_OtherAssetRef_(const OtherAssetRef& value) {
+    return std::optional<OtherAssetRef>(value);
+  }
+  
+  // pragma MARK: std::optional<NothingAssetRef>
+  /**
+   * Specialized version of `std::optional<NothingAssetRef>`.
+   */
+  using std__optional_NothingAssetRef_ = std::optional<NothingAssetRef>;
+  inline std::optional<NothingAssetRef> create_std__optional_NothingAssetRef_(const NothingAssetRef& value) {
+    return std::optional<NothingAssetRef>(value);
+  }
+  
   // pragma MARK: std::vector<TradeQuote>
   /**
    * Specialized version of `std::vector<TradeQuote>`.
@@ -632,40 +806,6 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return std::optional<NothingAssetQuoteRequest>(value);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<Trade>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<Trade>>`.
-   */
-  using std__shared_ptr_Promise_Trade__ = std::shared_ptr<Promise<Trade>>;
-  inline std::shared_ptr<Promise<Trade>> create_std__shared_ptr_Promise_Trade__() {
-    return Promise<Trade>::create();
-  }
-  inline PromiseHolder<Trade> wrap_std__shared_ptr_Promise_Trade__(std::shared_ptr<Promise<Trade>> promise) {
-    return PromiseHolder<Trade>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const Trade& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const Trade&)>`.
-   */
-  using Func_void_Trade = std::function<void(const Trade& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const Trade& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_Trade_Wrapper final {
-  public:
-    explicit Func_void_Trade_Wrapper(std::function<void(const Trade& /* result */)>&& func): _function(std::make_shared<std::function<void(const Trade& /* result */)>>(std::move(func))) {}
-    inline void call(Trade result) const {
-      _function->operator()(result);
-    }
-  private:
-    std::shared_ptr<std::function<void(const Trade& /* result */)>> _function;
-  };
-  Func_void_Trade create_Func_void_Trade(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_Trade_Wrapper wrap_Func_void_Trade(Func_void_Trade value) {
-    return Func_void_Trade_Wrapper(std::move(value));
-  }
-  
   // pragma MARK: std::vector<std::shared_ptr<AnyMap>>
   /**
    * Specialized version of `std::vector<std::shared_ptr<AnyMap>>`.
@@ -775,6 +915,15 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<LinkedAccount>>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<LinkedAccount>>>
+  using Result_std__shared_ptr_Promise_LinkedAccount___ = Result<std::shared_ptr<Promise<LinkedAccount>>>;
+  inline Result_std__shared_ptr_Promise_LinkedAccount___ create_Result_std__shared_ptr_Promise_LinkedAccount___(const std::shared_ptr<Promise<LinkedAccount>>& value) {
+    return Result<std::shared_ptr<Promise<LinkedAccount>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_LinkedAccount___ create_Result_std__shared_ptr_Promise_LinkedAccount___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<LinkedAccount>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<void>>>
   using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
   inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) {
@@ -793,6 +942,15 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<AssetAccount>>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<AssetAccount>>>
+  using Result_std__shared_ptr_Promise_AssetAccount___ = Result<std::shared_ptr<Promise<AssetAccount>>>;
+  inline Result_std__shared_ptr_Promise_AssetAccount___ create_Result_std__shared_ptr_Promise_AssetAccount___(const std::shared_ptr<Promise<AssetAccount>>& value) {
+    return Result<std::shared_ptr<Promise<AssetAccount>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_AssetAccount___ create_Result_std__shared_ptr_Promise_AssetAccount___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<AssetAccount>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<Trade>>>>
   using Result_std__shared_ptr_Promise_std__vector_Trade____ = Result<std::shared_ptr<Promise<std::vector<Trade>>>>;
   inline Result_std__shared_ptr_Promise_std__vector_Trade____ create_Result_std__shared_ptr_Promise_std__vector_Trade____(const std::shared_ptr<Promise<std::vector<Trade>>>& value) {
@@ -802,15 +960,6 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Result<std::shared_ptr<Promise<std::vector<Trade>>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<TradeQuote>>>>
-  using Result_std__shared_ptr_Promise_std__vector_TradeQuote____ = Result<std::shared_ptr<Promise<std::vector<TradeQuote>>>>;
-  inline Result_std__shared_ptr_Promise_std__vector_TradeQuote____ create_Result_std__shared_ptr_Promise_std__vector_TradeQuote____(const std::shared_ptr<Promise<std::vector<TradeQuote>>>& value) {
-    return Result<std::shared_ptr<Promise<std::vector<TradeQuote>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__vector_TradeQuote____ create_Result_std__shared_ptr_Promise_std__vector_TradeQuote____(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::vector<TradeQuote>>>>::withError(error);
-  }
-  
   // pragma MARK: Result<std::shared_ptr<Promise<Trade>>>
   using Result_std__shared_ptr_Promise_Trade___ = Result<std::shared_ptr<Promise<Trade>>>;
   inline Result_std__shared_ptr_Promise_Trade___ create_Result_std__shared_ptr_Promise_Trade___(const std::shared_ptr<Promise<Trade>>& value) {
@@ -820,6 +969,15 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Result<std::shared_ptr<Promise<Trade>>>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<TradeQuote>>>>
+  using Result_std__shared_ptr_Promise_std__vector_TradeQuote____ = Result<std::shared_ptr<Promise<std::vector<TradeQuote>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_TradeQuote____ create_Result_std__shared_ptr_Promise_std__vector_TradeQuote____(const std::shared_ptr<Promise<std::vector<TradeQuote>>>& value) {
+    return Result<std::shared_ptr<Promise<std::vector<TradeQuote>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_TradeQuote____ create_Result_std__shared_ptr_Promise_std__vector_TradeQuote____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<TradeQuote>>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>>>
   using Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_AnyMap_____ = Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>>>;
   inline Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_AnyMap_____ create_Result_std__shared_ptr_Promise_std__vector_std__shared_ptr_AnyMap_____(const std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>>& value) {

package/nitrogen/generated/ios/ReactNativeCandle-Swift-Cxx-Umbrella.hpp

@@ -26,18 +26,20 @@ namespace margelo::nitro::rncandle { struct AssetAccountDetails; }
 namespace margelo::nitro::rncandle { enum class AssetAccountKind; }
 // Forward declaration of `AssetAccountQuery` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccountQuery; }
+// Forward declaration of `AssetAccountRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct AssetAccountRef; }
 // Forward declaration of `AssetAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccount; }
 // Forward declaration of `Coordinates` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct Coordinates; }
 // Forward declaration of `Counterparty` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct Counterparty; }
-// Forward declaration of `ExecuteTradeRequest` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct ExecuteTradeRequest; }
 // Forward declaration of `FiatAccountDetails` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct FiatAccountDetails; }
 // Forward declaration of `FiatAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct FiatAssetQuoteRequest; }
+// Forward declaration of `FiatAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FiatAssetRef; }
 // Forward declaration of `FiatAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct FiatAsset; }
 // Forward declaration of `HybridRNCandleSpec` to properly resolve imports.
@@ -48,12 +50,16 @@ namespace margelo::nitro::rncandle { struct InactiveLinkedAccountDetails; }
 namespace margelo::nitro::rncandle { enum class LegalAccountKind; }
 // Forward declaration of `LinkedAccountDetails` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct LinkedAccountDetails; }
+// Forward declaration of `LinkedAccountRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct LinkedAccountRef; }
 // Forward declaration of `LinkedAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct LinkedAccount; }
 // Forward declaration of `MarketAccountDetails` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct MarketAccountDetails; }
 // Forward declaration of `MarketAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct MarketAssetQuoteRequest; }
+// Forward declaration of `MarketTradeAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MarketTradeAssetRef; }
 // Forward declaration of `MarketTradeAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct MarketTradeAsset; }
 // Forward declaration of `MerchantCounterparty` to properly resolve imports.
@@ -62,8 +68,12 @@ namespace margelo::nitro::rncandle { struct MerchantCounterparty; }
 namespace margelo::nitro::rncandle { struct MerchantLocation; }
 // Forward declaration of `NothingAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct NothingAssetQuoteRequest; }
+// Forward declaration of `NothingAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct NothingAssetRef; }
 // Forward declaration of `NothingAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct NothingAsset; }
+// Forward declaration of `OtherAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct OtherAssetRef; }
 // Forward declaration of `OtherAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct OtherAsset; }
 // Forward declaration of `PresentationBackground` to properly resolve imports.
@@ -78,20 +88,28 @@ namespace margelo::nitro::rncandle { enum class Service; }
 namespace margelo::nitro::rncandle { struct ToolCall; }
 // Forward declaration of `TradeAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeAssetQuoteRequest; }
+// Forward declaration of `TradeAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeAssetRef; }
 // Forward declaration of `TradeAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeAsset; }
+// Forward declaration of `TradeExecutionResult` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeExecutionResult; }
 // Forward declaration of `TradeQuery` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuery; }
 // Forward declaration of `TradeQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuoteRequest; }
 // Forward declaration of `TradeQuote` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuote; }
+// Forward declaration of `TradeRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeRef; }
 // Forward declaration of `TradeState` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class TradeState; }
 // Forward declaration of `Trade` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct Trade; }
 // Forward declaration of `TransportAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TransportAssetQuoteRequest; }
+// Forward declaration of `TransportAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TransportAssetRef; }
 // Forward declaration of `TransportAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TransportAsset; }
 // Forward declaration of `UserCounterparty` to properly resolve imports.
@@ -109,25 +127,30 @@ namespace margelo::nitro::rncandle { struct WireDetails; }
 #include "AssetAccountDetails.hpp"
 #include "AssetAccountKind.hpp"
 #include "AssetAccountQuery.hpp"
+#include "AssetAccountRef.hpp"
 #include "Coordinates.hpp"
 #include "Counterparty.hpp"
-#include "ExecuteTradeRequest.hpp"
 #include "FiatAccountDetails.hpp"
 #include "FiatAsset.hpp"
 #include "FiatAssetQuoteRequest.hpp"
+#include "FiatAssetRef.hpp"
 #include "HybridRNCandleSpec.hpp"
 #include "InactiveLinkedAccountDetails.hpp"
 #include "LegalAccountKind.hpp"
 #include "LinkedAccount.hpp"
 #include "LinkedAccountDetails.hpp"
+#include "LinkedAccountRef.hpp"
 #include "MarketAccountDetails.hpp"
 #include "MarketAssetQuoteRequest.hpp"
 #include "MarketTradeAsset.hpp"
+#include "MarketTradeAssetRef.hpp"
 #include "MerchantCounterparty.hpp"
 #include "MerchantLocation.hpp"
 #include "NothingAsset.hpp"
 #include "NothingAssetQuoteRequest.hpp"
+#include "NothingAssetRef.hpp"
 #include "OtherAsset.hpp"
+#include "OtherAssetRef.hpp"
 #include "PresentationBackground.hpp"
 #include "PresentationStyle.hpp"
 #include "Service.hpp"
@@ -136,12 +159,16 @@ namespace margelo::nitro::rncandle { struct WireDetails; }
 #include "Trade.hpp"
 #include "TradeAsset.hpp"
 #include "TradeAssetQuoteRequest.hpp"
+#include "TradeAssetRef.hpp"
+#include "TradeExecutionResult.hpp"
 #include "TradeQuery.hpp"
 #include "TradeQuote.hpp"
 #include "TradeQuoteRequest.hpp"
+#include "TradeRef.hpp"
 #include "TradeState.hpp"
 #include "TransportAsset.hpp"
 #include "TransportAssetQuoteRequest.hpp"
+#include "TransportAssetRef.hpp"
 #include "UserCounterparty.hpp"
 #include "WireDetails.hpp"
 #include <NitroModules/AnyMap.hpp>