react-native-candle 0.1.18 → 0.1.20

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.
@@ -74,6 +82,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 +108,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,11 +117,14 @@ 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"
@@ -119,6 +133,7 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include "TradeState.hpp"
 #include "TransportAsset.hpp"
 #include "TransportAssetQuoteRequest.hpp"
+#include "TransportAssetRef.hpp"
 #include "UserCounterparty.hpp"
 #include "WireDetails.hpp"
 #include <NitroModules/AnyMap.hpp>
@@ -274,6 +289,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,6 +434,40 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return std::optional<AssetAccountKind>(value);
   }
   
+  // pragma MARK: std::shared_ptr<Promise<AssetAccount>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<AssetAccount>>`.
+   */
+  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();
+  }
+  inline PromiseHolder<AssetAccount> wrap_std__shared_ptr_Promise_AssetAccount__(std::shared_ptr<Promise<AssetAccount>> promise) {
+    return PromiseHolder<AssetAccount>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const AssetAccount& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const AssetAccount&)>`.
+   */
+  using Func_void_AssetAccount = std::function<void(const AssetAccount& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const AssetAccount& / * result * /)>`, this can be used from Swift.
+   */
+  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::optional<MerchantLocation>
   /**
    * Specialized version of `std::optional<MerchantLocation>`.
@@ -533,6 +594,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 +772,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 +881,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 +908,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 +926,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 +935,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,16 +26,22 @@ 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.
@@ -46,12 +52,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.
@@ -60,8 +70,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.
@@ -76,6 +90,8 @@ 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 `TradeQuery` to properly resolve imports.
@@ -84,12 +100,16 @@ namespace margelo::nitro::rncandle { struct TradeQuery; }
 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.
@@ -107,24 +127,31 @@ 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"
@@ -133,12 +160,15 @@ namespace margelo::nitro::rncandle { struct WireDetails; }
 #include "Trade.hpp"
 #include "TradeAsset.hpp"
 #include "TradeAssetQuoteRequest.hpp"
+#include "TradeAssetRef.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>

package/nitrogen/generated/ios/c++/HybridRNCandleSpecSwift.hpp

@@ -28,6 +28,8 @@ namespace margelo::nitro::rncandle { struct ActiveLinkedAccountDetails; }
 namespace margelo::nitro::rncandle { struct InactiveLinkedAccountDetails; }
 // Forward declaration of `AppUser` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AppUser; }
+// Forward declaration of `LinkedAccountRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct LinkedAccountRef; }
 // Forward declaration of `AssetAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccount; }
 // Forward declaration of `LegalAccountKind` to properly resolve imports.
@@ -48,6 +50,8 @@ namespace margelo::nitro::rncandle { struct MarketAccountDetails; }
 namespace margelo::nitro::rncandle { struct AssetAccountQuery; }
 // 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 `Trade` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct Trade; }
 // Forward declaration of `TradeState` to properly resolve imports.
@@ -80,6 +84,20 @@ namespace margelo::nitro::rncandle { struct OtherAsset; }
 namespace margelo::nitro::rncandle { struct NothingAsset; }
 // Forward declaration of `TradeQuery` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuery; }
+// 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 `MarketTradeAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MarketTradeAssetRef; }
+// Forward declaration of `TransportAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TransportAssetRef; }
+// 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 `TradeQuote` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuote; }
 // Forward declaration of `TradeQuoteRequest` to properly resolve imports.
@@ -94,6 +112,8 @@ namespace margelo::nitro::rncandle { struct MarketAssetQuoteRequest; }
 namespace margelo::nitro::rncandle { struct TransportAssetQuoteRequest; }
 // Forward declaration of `NothingAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct NothingAssetQuoteRequest; }
+// Forward declaration of `ExecuteTradeRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct ExecuteTradeRequest; }
 // Forward declaration of `AnyMap` to properly resolve imports.
 namespace NitroModules { class AnyMap; }
 // Forward declaration of `ToolCall` to properly resolve imports.
@@ -112,6 +132,7 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "InactiveLinkedAccountDetails.hpp"
 #include "AppUser.hpp"
 #include <NitroModules/Promise.hpp>
+#include "LinkedAccountRef.hpp"
 #include "AssetAccount.hpp"
 #include "LegalAccountKind.hpp"
 #include "AssetAccountDetails.hpp"
@@ -122,6 +143,7 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "MarketAccountDetails.hpp"
 #include "AssetAccountQuery.hpp"
 #include "AssetAccountKind.hpp"
+#include "AssetAccountRef.hpp"
 #include "Trade.hpp"
 #include "TradeState.hpp"
 #include "Counterparty.hpp"
@@ -138,6 +160,13 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "OtherAsset.hpp"
 #include "NothingAsset.hpp"
 #include "TradeQuery.hpp"
+#include "TradeRef.hpp"
+#include "TradeAssetRef.hpp"
+#include "FiatAssetRef.hpp"
+#include "MarketTradeAssetRef.hpp"
+#include "TransportAssetRef.hpp"
+#include "OtherAssetRef.hpp"
+#include "NothingAssetRef.hpp"
 #include "TradeQuote.hpp"
 #include "TradeQuoteRequest.hpp"
 #include "TradeAssetQuoteRequest.hpp"
@@ -145,6 +174,7 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "MarketAssetQuoteRequest.hpp"
 #include "TransportAssetQuoteRequest.hpp"
 #include "NothingAssetQuoteRequest.hpp"
+#include "ExecuteTradeRequest.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include "ToolCall.hpp"
 
@@ -207,8 +237,16 @@ namespace margelo::nitro::rncandle {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<void>> unlinkAccount(const std::string& linkedAccountID) override {
-      auto __result = _swiftPart.unlinkAccount(linkedAccountID);
+    inline std::shared_ptr<Promise<LinkedAccount>> getLinkedAccount(const LinkedAccountRef& ref) override {
+      auto __result = _swiftPart.getLinkedAccount(ref);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> unlinkAccount(const LinkedAccountRef& ref) override {
+      auto __result = _swiftPart.unlinkAccount(ref);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -223,6 +261,14 @@ namespace margelo::nitro::rncandle {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<AssetAccount>> getAssetAccount(const AssetAccountRef& ref) override {
+      auto __result = _swiftPart.getAssetAccount(ref);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<std::vector<Trade>>> getTrades(const TradeQuery& query) override {
       auto __result = _swiftPart.getTrades(query);
       if (__result.hasError()) [[unlikely]] {
@@ -231,6 +277,14 @@ namespace margelo::nitro::rncandle {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<Trade>> getTrade(const TradeRef& ref) override {
+      auto __result = _swiftPart.getTrade(ref);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<std::vector<TradeQuote>>> getTradeQuotes(const TradeQuoteRequest& request) override {
       auto __result = _swiftPart.getTradeQuotes(request);
       if (__result.hasError()) [[unlikely]] {
@@ -239,8 +293,8 @@ namespace margelo::nitro::rncandle {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<Trade>> submitTrade(const std::string& serviceTradeID) override {
-      auto __result = _swiftPart.submitTrade(serviceTradeID);
+    inline std::shared_ptr<Promise<Trade>> executeTrade(const ExecuteTradeRequest& request) override {
+      auto __result = _swiftPart.executeTrade(request);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

package/nitrogen/generated/ios/swift/AssetAccountRef.swift

@@ -0,0 +1,55 @@
+///
+/// AssetAccountRef.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// Represents an instance of `AssetAccountRef`, backed by a C++ struct.
+public typealias AssetAccountRef = margelo.nitro.rncandle.AssetAccountRef
+
+extension AssetAccountRef {
+  private typealias bridge = margelo.nitro.rncandle.bridge.swift
+
+  /**
+   * Create a new instance of `AssetAccountRef`.
+   */
+  public init(linkedAccountID: String, assetKind: String, serviceAccountID: String) {
+    self.init(std.string(linkedAccountID), std.string(assetKind), std.string(serviceAccountID))
+  }
+
+  public var linkedAccountID: String {
+    @inline(__always)
+    get {
+      return String(self.__linkedAccountID)
+    }
+    @inline(__always)
+    set {
+      self.__linkedAccountID = std.string(newValue)
+    }
+  }
+
+  public var assetKind: String {
+    @inline(__always)
+    get {
+      return String(self.__assetKind)
+    }
+    @inline(__always)
+    set {
+      self.__assetKind = std.string(newValue)
+    }
+  }
+
+  public var serviceAccountID: String {
+    @inline(__always)
+    get {
+      return String(self.__serviceAccountID)
+    }
+    @inline(__always)
+    set {
+      self.__serviceAccountID = std.string(newValue)
+    }
+  }
+}