react-native-candle 0.1.16 → 0.1.18

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

@@ -8,29 +8,119 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `ACHAccountKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class ACHAccountKind; }
+// Forward declaration of `ACHDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct ACHDetails; }
+// Forward declaration of `ActiveLinkedAccountDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct ActiveLinkedAccountDetails; }
+// Forward declaration of `Address` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Address; }
 // Forward declaration of `AnyMap` to properly resolve imports.
 namespace NitroModules { class AnyMap; }
-// Forward declaration of `Details` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct Details; }
+// Forward declaration of `AssetAccountDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct AssetAccountDetails; }
+// Forward declaration of `AssetAccountKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class AssetAccountKind; }
+// 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 `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 `FiatAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FiatAsset; }
 // Forward declaration of `HybridRNCandleSpec` to properly resolve imports.
 namespace margelo::nitro::rncandle { class HybridRNCandleSpec; }
+// Forward declaration of `InactiveLinkedAccountDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct InactiveLinkedAccountDetails; }
+// Forward declaration of `LegalAccountKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class LegalAccountKind; }
+// Forward declaration of `LinkedAccountDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct LinkedAccountDetails; }
 // 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 `MarketTradeAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MarketTradeAsset; }
+// 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 `NothingAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct NothingAssetQuoteRequest; }
+// Forward declaration of `NothingAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct NothingAsset; }
+// Forward declaration of `OtherAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct OtherAsset; }
+// Forward declaration of `ServiceCounterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct ServiceCounterparty; }
 // Forward declaration of `Service` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class Service; }
-// Forward declaration of `State` to properly resolve imports.
-namespace margelo::nitro::rncandle { enum class State; }
+// Forward declaration of `TradeAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeAsset; }
+// Forward declaration of `TradeQuote` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeQuote; }
+// 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 `TransportAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TransportAsset; }
+// Forward declaration of `UserCounterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct UserCounterparty; }
+// Forward declaration of `WireDetails` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct WireDetails; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridRNCandleSpec_cxx` to properly resolve imports.
 namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 
 // Include C++ defined types
-#include "Details.hpp"
+#include "ACHAccountKind.hpp"
+#include "ACHDetails.hpp"
+#include "ActiveLinkedAccountDetails.hpp"
+#include "Address.hpp"
+#include "AssetAccount.hpp"
+#include "AssetAccountDetails.hpp"
+#include "AssetAccountKind.hpp"
+#include "Coordinates.hpp"
+#include "Counterparty.hpp"
+#include "FiatAccountDetails.hpp"
+#include "FiatAsset.hpp"
+#include "FiatAssetQuoteRequest.hpp"
 #include "HybridRNCandleSpec.hpp"
+#include "InactiveLinkedAccountDetails.hpp"
+#include "LegalAccountKind.hpp"
 #include "LinkedAccount.hpp"
+#include "LinkedAccountDetails.hpp"
+#include "MarketAccountDetails.hpp"
+#include "MarketAssetQuoteRequest.hpp"
+#include "MarketTradeAsset.hpp"
+#include "MerchantCounterparty.hpp"
+#include "MerchantLocation.hpp"
+#include "NothingAsset.hpp"
+#include "NothingAssetQuoteRequest.hpp"
+#include "OtherAsset.hpp"
 #include "Service.hpp"
-#include "State.hpp"
+#include "ServiceCounterparty.hpp"
+#include "Trade.hpp"
+#include "TradeAsset.hpp"
+#include "TradeQuote.hpp"
+#include "TradeState.hpp"
+#include "TransportAsset.hpp"
+#include "TransportAssetQuoteRequest.hpp"
+#include "UserCounterparty.hpp"
+#include "WireDetails.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
@@ -77,13 +167,22 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return std::optional<std::string>(value);
   }
   
-  // pragma MARK: std::optional<Details>
+  // pragma MARK: std::optional<ActiveLinkedAccountDetails>
   /**
-   * Specialized version of `std::optional<Details>`.
+   * Specialized version of `std::optional<ActiveLinkedAccountDetails>`.
    */
-  using std__optional_Details_ = std::optional<Details>;
-  inline std::optional<Details> create_std__optional_Details_(const Details& value) {
-    return std::optional<Details>(value);
+  using std__optional_ActiveLinkedAccountDetails_ = std::optional<ActiveLinkedAccountDetails>;
+  inline std::optional<ActiveLinkedAccountDetails> create_std__optional_ActiveLinkedAccountDetails_(const ActiveLinkedAccountDetails& value) {
+    return std::optional<ActiveLinkedAccountDetails>(value);
+  }
+  
+  // pragma MARK: std::optional<InactiveLinkedAccountDetails>
+  /**
+   * Specialized version of `std::optional<InactiveLinkedAccountDetails>`.
+   */
+  using std__optional_InactiveLinkedAccountDetails_ = std::optional<InactiveLinkedAccountDetails>;
+  inline std::optional<InactiveLinkedAccountDetails> create_std__optional_InactiveLinkedAccountDetails_(const InactiveLinkedAccountDetails& value) {
+    return std::optional<InactiveLinkedAccountDetails>(value);
   }
   
   // pragma MARK: std::function<void(const LinkedAccount& /* account */)>
@@ -209,38 +308,362 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Func_void_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::string>>
+  // pragma MARK: std::optional<double>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
+   * Specialized version of `std::optional<double>`.
    */
-  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
-  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() {
-    return Promise<std::string>::create();
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) {
+    return std::optional<double>(value);
   }
-  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) {
-    return PromiseHolder<std::string>(std::move(promise));
+  
+  // pragma MARK: std::optional<ACHDetails>
+  /**
+   * Specialized version of `std::optional<ACHDetails>`.
+   */
+  using std__optional_ACHDetails_ = std::optional<ACHDetails>;
+  inline std::optional<ACHDetails> create_std__optional_ACHDetails_(const ACHDetails& value) {
+    return std::optional<ACHDetails>(value);
   }
   
-  // pragma MARK: std::function<void(const std::string& /* result */)>
+  // pragma MARK: std::optional<WireDetails>
   /**
-   * Specialized version of `std::function<void(const std::string&)>`.
+   * Specialized version of `std::optional<WireDetails>`.
    */
-  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
+  using std__optional_WireDetails_ = std::optional<WireDetails>;
+  inline std::optional<WireDetails> create_std__optional_WireDetails_(const WireDetails& value) {
+    return std::optional<WireDetails>(value);
+  }
+  
+  // pragma MARK: std::optional<FiatAccountDetails>
   /**
-   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
+   * Specialized version of `std::optional<FiatAccountDetails>`.
    */
-  class Func_void_std__string_Wrapper final {
+  using std__optional_FiatAccountDetails_ = std::optional<FiatAccountDetails>;
+  inline std::optional<FiatAccountDetails> create_std__optional_FiatAccountDetails_(const FiatAccountDetails& value) {
+    return std::optional<FiatAccountDetails>(value);
+  }
+  
+  // pragma MARK: std::optional<MarketAccountDetails>
+  /**
+   * Specialized version of `std::optional<MarketAccountDetails>`.
+   */
+  using std__optional_MarketAccountDetails_ = std::optional<MarketAccountDetails>;
+  inline std::optional<MarketAccountDetails> create_std__optional_MarketAccountDetails_(const MarketAccountDetails& value) {
+    return std::optional<MarketAccountDetails>(value);
+  }
+  
+  // pragma MARK: std::vector<AssetAccount>
+  /**
+   * Specialized version of `std::vector<AssetAccount>`.
+   */
+  using std__vector_AssetAccount_ = std::vector<AssetAccount>;
+  inline std::vector<AssetAccount> create_std__vector_AssetAccount_(size_t size) {
+    std::vector<AssetAccount> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<AssetAccount>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<AssetAccount>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_AssetAccount___ = std::shared_ptr<Promise<std::vector<AssetAccount>>>;
+  inline std::shared_ptr<Promise<std::vector<AssetAccount>>> create_std__shared_ptr_Promise_std__vector_AssetAccount___() {
+    return Promise<std::vector<AssetAccount>>::create();
+  }
+  inline PromiseHolder<std::vector<AssetAccount>> wrap_std__shared_ptr_Promise_std__vector_AssetAccount___(std::shared_ptr<Promise<std::vector<AssetAccount>>> promise) {
+    return PromiseHolder<std::vector<AssetAccount>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<AssetAccount>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<AssetAccount>&)>`.
+   */
+  using Func_void_std__vector_AssetAccount_ = std::function<void(const std::vector<AssetAccount>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<AssetAccount>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_AssetAccount__Wrapper final {
   public:
-    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
-    inline void call(std::string result) const {
+    explicit Func_void_std__vector_AssetAccount__Wrapper(std::function<void(const std::vector<AssetAccount>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<AssetAccount>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<AssetAccount> result) const {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::string& /* result */)>> _function;
+    std::shared_ptr<std::function<void(const std::vector<AssetAccount>& /* result */)>> _function;
   };
-  Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) {
-    return Func_void_std__string_Wrapper(std::move(value));
+  Func_void_std__vector_AssetAccount_ create_Func_void_std__vector_AssetAccount_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_AssetAccount__Wrapper wrap_Func_void_std__vector_AssetAccount_(Func_void_std__vector_AssetAccount_ value) {
+    return Func_void_std__vector_AssetAccount__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<AssetAccountKind>
+  /**
+   * Specialized version of `std::optional<AssetAccountKind>`.
+   */
+  using std__optional_AssetAccountKind_ = std::optional<AssetAccountKind>;
+  inline std::optional<AssetAccountKind> create_std__optional_AssetAccountKind_(const AssetAccountKind& value) {
+    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>
+  /**
+   * 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::vector<Trade>
+  /**
+   * Specialized version of `std::vector<Trade>`.
+   */
+  using std__vector_Trade_ = std::vector<Trade>;
+  inline std::vector<Trade> create_std__vector_Trade_(size_t size) {
+    std::vector<Trade> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<Trade>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<Trade>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_Trade___ = std::shared_ptr<Promise<std::vector<Trade>>>;
+  inline std::shared_ptr<Promise<std::vector<Trade>>> create_std__shared_ptr_Promise_std__vector_Trade___() {
+    return Promise<std::vector<Trade>>::create();
+  }
+  inline PromiseHolder<std::vector<Trade>> wrap_std__shared_ptr_Promise_std__vector_Trade___(std::shared_ptr<Promise<std::vector<Trade>>> promise) {
+    return PromiseHolder<std::vector<Trade>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<Trade>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<Trade>&)>`.
+   */
+  using Func_void_std__vector_Trade_ = std::function<void(const std::vector<Trade>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<Trade>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_Trade__Wrapper final {
+  public:
+    explicit Func_void_std__vector_Trade__Wrapper(std::function<void(const std::vector<Trade>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<Trade>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<Trade> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<Trade>& /* result */)>> _function;
+  };
+  Func_void_std__vector_Trade_ create_Func_void_std__vector_Trade_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_Trade__Wrapper wrap_Func_void_std__vector_Trade_(Func_void_std__vector_Trade_ value) {
+    return Func_void_std__vector_Trade__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<TradeQuote>
+  /**
+   * Specialized version of `std::vector<TradeQuote>`.
+   */
+  using std__vector_TradeQuote_ = std::vector<TradeQuote>;
+  inline std::vector<TradeQuote> create_std__vector_TradeQuote_(size_t size) {
+    std::vector<TradeQuote> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<TradeQuote>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<TradeQuote>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_TradeQuote___ = std::shared_ptr<Promise<std::vector<TradeQuote>>>;
+  inline std::shared_ptr<Promise<std::vector<TradeQuote>>> create_std__shared_ptr_Promise_std__vector_TradeQuote___() {
+    return Promise<std::vector<TradeQuote>>::create();
+  }
+  inline PromiseHolder<std::vector<TradeQuote>> wrap_std__shared_ptr_Promise_std__vector_TradeQuote___(std::shared_ptr<Promise<std::vector<TradeQuote>>> promise) {
+    return PromiseHolder<std::vector<TradeQuote>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<TradeQuote>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<TradeQuote>&)>`.
+   */
+  using Func_void_std__vector_TradeQuote_ = std::function<void(const std::vector<TradeQuote>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<TradeQuote>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_TradeQuote__Wrapper final {
+  public:
+    explicit Func_void_std__vector_TradeQuote__Wrapper(std::function<void(const std::vector<TradeQuote>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<TradeQuote>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<TradeQuote> result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::vector<TradeQuote>& /* result */)>> _function;
+  };
+  Func_void_std__vector_TradeQuote_ create_Func_void_std__vector_TradeQuote_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_TradeQuote__Wrapper wrap_Func_void_std__vector_TradeQuote_(Func_void_std__vector_TradeQuote_ value) {
+    return Func_void_std__vector_TradeQuote__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<FiatAssetQuoteRequest>
+  /**
+   * Specialized version of `std::optional<FiatAssetQuoteRequest>`.
+   */
+  using std__optional_FiatAssetQuoteRequest_ = std::optional<FiatAssetQuoteRequest>;
+  inline std::optional<FiatAssetQuoteRequest> create_std__optional_FiatAssetQuoteRequest_(const FiatAssetQuoteRequest& value) {
+    return std::optional<FiatAssetQuoteRequest>(value);
+  }
+  
+  // pragma MARK: std::optional<MarketAssetQuoteRequest>
+  /**
+   * Specialized version of `std::optional<MarketAssetQuoteRequest>`.
+   */
+  using std__optional_MarketAssetQuoteRequest_ = std::optional<MarketAssetQuoteRequest>;
+  inline std::optional<MarketAssetQuoteRequest> create_std__optional_MarketAssetQuoteRequest_(const MarketAssetQuoteRequest& value) {
+    return std::optional<MarketAssetQuoteRequest>(value);
+  }
+  
+  // pragma MARK: std::optional<Coordinates>
+  /**
+   * Specialized version of `std::optional<Coordinates>`.
+   */
+  using std__optional_Coordinates_ = std::optional<Coordinates>;
+  inline std::optional<Coordinates> create_std__optional_Coordinates_(const Coordinates& value) {
+    return std::optional<Coordinates>(value);
+  }
+  
+  // pragma MARK: std::optional<Address>
+  /**
+   * Specialized version of `std::optional<Address>`.
+   */
+  using std__optional_Address_ = std::optional<Address>;
+  inline std::optional<Address> create_std__optional_Address_(const Address& value) {
+    return std::optional<Address>(value);
+  }
+  
+  // pragma MARK: std::optional<TransportAssetQuoteRequest>
+  /**
+   * Specialized version of `std::optional<TransportAssetQuoteRequest>`.
+   */
+  using std__optional_TransportAssetQuoteRequest_ = std::optional<TransportAssetQuoteRequest>;
+  inline std::optional<TransportAssetQuoteRequest> create_std__optional_TransportAssetQuoteRequest_(const TransportAssetQuoteRequest& value) {
+    return std::optional<TransportAssetQuoteRequest>(value);
+  }
+  
+  // pragma MARK: std::optional<NothingAssetQuoteRequest>
+  /**
+   * Specialized version of `std::optional<NothingAssetQuoteRequest>`.
+   */
+  using std__optional_NothingAssetQuoteRequest_ = std::optional<NothingAssetQuoteRequest>;
+  inline std::optional<NothingAssetQuoteRequest> create_std__optional_NothingAssetQuoteRequest_(const NothingAssetQuoteRequest& value) {
+    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>>
@@ -288,6 +711,40 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Func_void_std__vector_std__shared_ptr_AnyMap___Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<std::string>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
+   */
+  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
+  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() {
+    return Promise<std::string>::create();
+  }
+  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) {
+    return PromiseHolder<std::string>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_Wrapper final {
+  public:
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
+    inline void call(std::string result) const {
+      _function->operator()(result);
+    }
+  private:
+    std::shared_ptr<std::function<void(const std::string& /* result */)>> _function;
+  };
+  Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) {
+    return Func_void_std__string_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<margelo::nitro::rncandle::HybridRNCandleSpec>
   /**
    * Specialized version of `std::shared_ptr<margelo::nitro::rncandle::HybridRNCandleSpec>`.
@@ -327,13 +784,40 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
-  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) {
-    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<AssetAccount>>>>
+  using Result_std__shared_ptr_Promise_std__vector_AssetAccount____ = Result<std::shared_ptr<Promise<std::vector<AssetAccount>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_AssetAccount____ create_Result_std__shared_ptr_Promise_std__vector_AssetAccount____(const std::shared_ptr<Promise<std::vector<AssetAccount>>>& value) {
+    return Result<std::shared_ptr<Promise<std::vector<AssetAccount>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__vector_AssetAccount____ create_Result_std__shared_ptr_Promise_std__vector_AssetAccount____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<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) {
+    return Result<std::shared_ptr<Promise<std::vector<Trade>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_Trade____ create_Result_std__shared_ptr_Promise_std__vector_Trade____(const std::exception_ptr& error) {
+    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) {
+    return Result<std::shared_ptr<Promise<Trade>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_Trade___ create_Result_std__shared_ptr_Promise_Trade___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<Trade>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>>>
@@ -344,5 +828,14 @@ namespace margelo::nitro::rncandle::bridge::swift {
   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::exception_ptr& error) {
     return Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>>>::withError(error);
   }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
+  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) {
+    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::rncandle::bridge::swift