react-native-candle 0.1.43 → 0.1.45

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

@@ -16,8 +16,6 @@ namespace margelo::nitro::rncandle { struct ACHDetails; }
 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 `AssetAccountKind` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class AssetAccountKind; }
 // Forward declaration of `AssetAccount` to properly resolve imports.
@@ -26,6 +24,8 @@ namespace margelo::nitro::rncandle { struct AssetAccount; }
 namespace margelo::nitro::rncandle { struct AssetAccountsResponse; }
 // Forward declaration of `Coordinates` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct Coordinates; }
+// Forward declaration of `CounterpartyKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class CounterpartyKind; }
 // Forward declaration of `Counterparty` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct Counterparty; }
 // Forward declaration of `FiatAccount` to properly resolve imports.
@@ -44,12 +44,16 @@ namespace margelo::nitro::rncandle { class HybridRNCandleSpec; }
 namespace margelo::nitro::rncandle { struct InactiveLinkedAccountDetails; }
 // Forward declaration of `LinkedAccountDetails` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct LinkedAccountDetails; }
+// Forward declaration of `LinkedAccountState` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class LinkedAccountState; }
 // Forward declaration of `LinkedAccountStatusRef` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct LinkedAccountStatusRef; }
 // Forward declaration of `LinkedAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct LinkedAccount; }
 // Forward declaration of `MarketAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct MarketAccount; }
+// Forward declaration of `MarketAssetKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class MarketAssetKind; }
 // Forward declaration of `MarketAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct MarketAssetQuoteRequest; }
 // Forward declaration of `MarketTradeAssetRef` to properly resolve imports.
@@ -74,8 +78,8 @@ namespace margelo::nitro::rncandle { struct OtherAsset; }
 namespace margelo::nitro::rncandle { struct ServiceCounterparty; }
 // Forward declaration of `Service` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class Service; }
-// Forward declaration of `StatePayload` to properly resolve imports.
-namespace margelo::nitro::rncandle { enum class StatePayload; }
+// Forward declaration of `TradeAssetKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class TradeAssetKind; }
 // Forward declaration of `TradeAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeAsset; }
 // Forward declaration of `TradeExecutionResult` to properly resolve imports.
@@ -121,6 +125,7 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include "AssetAccountsResponse.hpp"
 #include "Coordinates.hpp"
 #include "Counterparty.hpp"
+#include "CounterpartyKind.hpp"
 #include "FiatAccount.hpp"
 #include "FiatAsset.hpp"
 #include "FiatAssetQuoteRequest.hpp"
@@ -130,8 +135,10 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include "InactiveLinkedAccountDetails.hpp"
 #include "LinkedAccount.hpp"
 #include "LinkedAccountDetails.hpp"
+#include "LinkedAccountState.hpp"
 #include "LinkedAccountStatusRef.hpp"
 #include "MarketAccount.hpp"
+#include "MarketAssetKind.hpp"
 #include "MarketAssetQuoteRequest.hpp"
 #include "MarketTradeAsset.hpp"
 #include "MarketTradeAssetRef.hpp"
@@ -144,9 +151,9 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include "OtherAssetRef.hpp"
 #include "Service.hpp"
 #include "ServiceCounterparty.hpp"
-#include "StatePayload.hpp"
 #include "Trade.hpp"
 #include "TradeAsset.hpp"
+#include "TradeAssetKind.hpp"
 #include "TradeExecutionResult.hpp"
 #include "TradeQuote.hpp"
 #include "TradeQuotesResponse.hpp"
@@ -160,7 +167,6 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include "UnavailableLinkedAccountDetails.hpp"
 #include "UserCounterparty.hpp"
 #include "WireDetails.hpp"
-#include <NitroModules/AnyMap.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -182,7 +188,7 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::vector<Service>`.
    */
   using std__vector_Service_ = std::vector<Service>;
-  inline std::vector<Service> create_std__vector_Service_(size_t size) {
+  inline std::vector<Service> create_std__vector_Service_(size_t size) noexcept {
     std::vector<Service> vector;
     vector.reserve(size);
     return vector;
@@ -193,45 +199,75 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::optional<std::vector<Service>>`.
    */
   using std__optional_std__vector_Service__ = std::optional<std::vector<Service>>;
-  inline std::optional<std::vector<Service>> create_std__optional_std__vector_Service__(const std::vector<Service>& value) {
+  inline std::optional<std::vector<Service>> create_std__optional_std__vector_Service__(const std::vector<Service>& value) noexcept {
     return std::optional<std::vector<Service>>(value);
   }
+  inline bool has_value_std__optional_std__vector_Service__(const std::optional<std::vector<Service>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<Service> get_std__optional_std__vector_Service__(const std::optional<std::vector<Service>>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::optional<std::string>
   /**
    * Specialized version of `std::optional<std::string>`.
    */
   using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) {
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
     return std::optional<std::string>(value);
   }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::optional<ActiveLinkedAccountDetails>
   /**
    * Specialized version of `std::optional<ActiveLinkedAccountDetails>`.
    */
   using std__optional_ActiveLinkedAccountDetails_ = std::optional<ActiveLinkedAccountDetails>;
-  inline std::optional<ActiveLinkedAccountDetails> create_std__optional_ActiveLinkedAccountDetails_(const ActiveLinkedAccountDetails& value) {
+  inline std::optional<ActiveLinkedAccountDetails> create_std__optional_ActiveLinkedAccountDetails_(const ActiveLinkedAccountDetails& value) noexcept {
     return std::optional<ActiveLinkedAccountDetails>(value);
   }
+  inline bool has_value_std__optional_ActiveLinkedAccountDetails_(const std::optional<ActiveLinkedAccountDetails>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ActiveLinkedAccountDetails get_std__optional_ActiveLinkedAccountDetails_(const std::optional<ActiveLinkedAccountDetails>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<InactiveLinkedAccountDetails> create_std__optional_InactiveLinkedAccountDetails_(const InactiveLinkedAccountDetails& value) noexcept {
     return std::optional<InactiveLinkedAccountDetails>(value);
   }
+  inline bool has_value_std__optional_InactiveLinkedAccountDetails_(const std::optional<InactiveLinkedAccountDetails>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline InactiveLinkedAccountDetails get_std__optional_InactiveLinkedAccountDetails_(const std::optional<InactiveLinkedAccountDetails>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::optional<UnavailableLinkedAccountDetails>
   /**
    * Specialized version of `std::optional<UnavailableLinkedAccountDetails>`.
    */
   using std__optional_UnavailableLinkedAccountDetails_ = std::optional<UnavailableLinkedAccountDetails>;
-  inline std::optional<UnavailableLinkedAccountDetails> create_std__optional_UnavailableLinkedAccountDetails_(const UnavailableLinkedAccountDetails& value) {
+  inline std::optional<UnavailableLinkedAccountDetails> create_std__optional_UnavailableLinkedAccountDetails_(const UnavailableLinkedAccountDetails& value) noexcept {
     return std::optional<UnavailableLinkedAccountDetails>(value);
   }
+  inline bool has_value_std__optional_UnavailableLinkedAccountDetails_(const std::optional<UnavailableLinkedAccountDetails>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline UnavailableLinkedAccountDetails get_std__optional_UnavailableLinkedAccountDetails_(const std::optional<UnavailableLinkedAccountDetails>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::function<void(const LinkedAccount& /* account */)>
   /**
@@ -243,15 +279,15 @@ namespace margelo::nitro::rncandle::bridge::swift {
    */
   class Func_void_LinkedAccount_Wrapper final {
   public:
-    explicit Func_void_LinkedAccount_Wrapper(std::function<void(const LinkedAccount& /* account */)>&& func): _function(std::make_shared<std::function<void(const LinkedAccount& /* account */)>>(std::move(func))) {}
-    inline void call(LinkedAccount account) const {
+    explicit Func_void_LinkedAccount_Wrapper(std::function<void(const LinkedAccount& /* account */)>&& func): _function(std::make_unique<std::function<void(const LinkedAccount& /* account */)>>(std::move(func))) {}
+    inline void call(LinkedAccount account) const noexcept {
       _function->operator()(account);
     }
   private:
-    std::shared_ptr<std::function<void(const LinkedAccount& /* account */)>> _function;
-  };
-  Func_void_LinkedAccount create_Func_void_LinkedAccount(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_LinkedAccount_Wrapper wrap_Func_void_LinkedAccount(Func_void_LinkedAccount value) {
+    std::unique_ptr<std::function<void(const LinkedAccount& /* account */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_LinkedAccount create_Func_void_LinkedAccount(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_LinkedAccount_Wrapper wrap_Func_void_LinkedAccount(Func_void_LinkedAccount value) noexcept {
     return Func_void_LinkedAccount_Wrapper(std::move(value));
   }
   
@@ -260,90 +296,150 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::optional<FiatAsset>`.
    */
   using std__optional_FiatAsset_ = std::optional<FiatAsset>;
-  inline std::optional<FiatAsset> create_std__optional_FiatAsset_(const FiatAsset& value) {
+  inline std::optional<FiatAsset> create_std__optional_FiatAsset_(const FiatAsset& value) noexcept {
     return std::optional<FiatAsset>(value);
   }
+  inline bool has_value_std__optional_FiatAsset_(const std::optional<FiatAsset>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline FiatAsset get_std__optional_FiatAsset_(const std::optional<FiatAsset>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<MarketTradeAsset> create_std__optional_MarketTradeAsset_(const MarketTradeAsset& value) noexcept {
     return std::optional<MarketTradeAsset>(value);
   }
+  inline bool has_value_std__optional_MarketTradeAsset_(const std::optional<MarketTradeAsset>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MarketTradeAsset get_std__optional_MarketTradeAsset_(const std::optional<MarketTradeAsset>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<TransportAsset> create_std__optional_TransportAsset_(const TransportAsset& value) noexcept {
     return std::optional<TransportAsset>(value);
   }
+  inline bool has_value_std__optional_TransportAsset_(const std::optional<TransportAsset>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TransportAsset get_std__optional_TransportAsset_(const std::optional<TransportAsset>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<OtherAsset> create_std__optional_OtherAsset_(const OtherAsset& value) noexcept {
     return std::optional<OtherAsset>(value);
   }
+  inline bool has_value_std__optional_OtherAsset_(const std::optional<OtherAsset>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline OtherAsset get_std__optional_OtherAsset_(const std::optional<OtherAsset>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<NothingAsset> create_std__optional_NothingAsset_(const NothingAsset& value) noexcept {
     return std::optional<NothingAsset>(value);
   }
+  inline bool has_value_std__optional_NothingAsset_(const std::optional<NothingAsset>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline NothingAsset get_std__optional_NothingAsset_(const std::optional<NothingAsset>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<MerchantLocation> create_std__optional_MerchantLocation_(const MerchantLocation& value) noexcept {
     return std::optional<MerchantLocation>(value);
   }
+  inline bool has_value_std__optional_MerchantLocation_(const std::optional<MerchantLocation>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MerchantLocation get_std__optional_MerchantLocation_(const std::optional<MerchantLocation>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<MerchantCounterparty> create_std__optional_MerchantCounterparty_(const MerchantCounterparty& value) noexcept {
     return std::optional<MerchantCounterparty>(value);
   }
+  inline bool has_value_std__optional_MerchantCounterparty_(const std::optional<MerchantCounterparty>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MerchantCounterparty get_std__optional_MerchantCounterparty_(const std::optional<MerchantCounterparty>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<UserCounterparty> create_std__optional_UserCounterparty_(const UserCounterparty& value) noexcept {
     return std::optional<UserCounterparty>(value);
   }
+  inline bool has_value_std__optional_UserCounterparty_(const std::optional<UserCounterparty>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline UserCounterparty get_std__optional_UserCounterparty_(const std::optional<UserCounterparty>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<ServiceCounterparty> create_std__optional_ServiceCounterparty_(const ServiceCounterparty& value) noexcept {
     return std::optional<ServiceCounterparty>(value);
   }
+  inline bool has_value_std__optional_ServiceCounterparty_(const std::optional<ServiceCounterparty>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ServiceCounterparty get_std__optional_ServiceCounterparty_(const std::optional<ServiceCounterparty>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<Trade> create_std__optional_Trade_(const Trade& value) noexcept {
     return std::optional<Trade>(value);
   }
+  inline bool has_value_std__optional_Trade_(const std::optional<Trade>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Trade get_std__optional_Trade_(const std::optional<Trade>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::function<void(const TradeExecutionResult& /* result */)>
   /**
@@ -355,15 +451,15 @@ namespace margelo::nitro::rncandle::bridge::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 {
+    explicit Func_void_TradeExecutionResult_Wrapper(std::function<void(const TradeExecutionResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const TradeExecutionResult& /* result */)>>(std::move(func))) {}
+    inline void call(TradeExecutionResult result) const noexcept {
       _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) {
+    std::unique_ptr<std::function<void(const TradeExecutionResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_TradeExecutionResult create_Func_void_TradeExecutionResult(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_TradeExecutionResult_Wrapper wrap_Func_void_TradeExecutionResult(Func_void_TradeExecutionResult value) noexcept {
     return Func_void_TradeExecutionResult_Wrapper(std::move(value));
   }
   
@@ -372,7 +468,7 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::vector<LinkedAccount>`.
    */
   using std__vector_LinkedAccount_ = std::vector<LinkedAccount>;
-  inline std::vector<LinkedAccount> create_std__vector_LinkedAccount_(size_t size) {
+  inline std::vector<LinkedAccount> create_std__vector_LinkedAccount_(size_t size) noexcept {
     std::vector<LinkedAccount> vector;
     vector.reserve(size);
     return vector;
@@ -383,10 +479,10 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::shared_ptr<Promise<std::vector<LinkedAccount>>>`.
    */
   using std__shared_ptr_Promise_std__vector_LinkedAccount___ = std::shared_ptr<Promise<std::vector<LinkedAccount>>>;
-  inline std::shared_ptr<Promise<std::vector<LinkedAccount>>> create_std__shared_ptr_Promise_std__vector_LinkedAccount___() {
+  inline std::shared_ptr<Promise<std::vector<LinkedAccount>>> create_std__shared_ptr_Promise_std__vector_LinkedAccount___() noexcept {
     return Promise<std::vector<LinkedAccount>>::create();
   }
-  inline PromiseHolder<std::vector<LinkedAccount>> wrap_std__shared_ptr_Promise_std__vector_LinkedAccount___(std::shared_ptr<Promise<std::vector<LinkedAccount>>> promise) {
+  inline PromiseHolder<std::vector<LinkedAccount>> wrap_std__shared_ptr_Promise_std__vector_LinkedAccount___(std::shared_ptr<Promise<std::vector<LinkedAccount>>> promise) noexcept {
     return PromiseHolder<std::vector<LinkedAccount>>(std::move(promise));
   }
   
@@ -400,15 +496,15 @@ namespace margelo::nitro::rncandle::bridge::swift {
    */
   class Func_void_std__vector_LinkedAccount__Wrapper final {
   public:
-    explicit Func_void_std__vector_LinkedAccount__Wrapper(std::function<void(const std::vector<LinkedAccount>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<LinkedAccount>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<LinkedAccount> result) const {
+    explicit Func_void_std__vector_LinkedAccount__Wrapper(std::function<void(const std::vector<LinkedAccount>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<LinkedAccount>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<LinkedAccount> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<LinkedAccount>& /* result */)>> _function;
-  };
-  Func_void_std__vector_LinkedAccount_ create_Func_void_std__vector_LinkedAccount_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_LinkedAccount__Wrapper wrap_Func_void_std__vector_LinkedAccount_(Func_void_std__vector_LinkedAccount_ value) {
+    std::unique_ptr<std::function<void(const std::vector<LinkedAccount>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_LinkedAccount_ create_Func_void_std__vector_LinkedAccount_(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_LinkedAccount__Wrapper wrap_Func_void_std__vector_LinkedAccount_(Func_void_std__vector_LinkedAccount_ value) noexcept {
     return Func_void_std__vector_LinkedAccount__Wrapper(std::move(value));
   }
   
@@ -422,15 +518,15 @@ namespace margelo::nitro::rncandle::bridge::swift {
    */
   class Func_void_std__exception_ptr_Wrapper final {
   public:
-    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_shared<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
-    inline void call(std::exception_ptr error) const {
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const noexcept {
       _function->operator()(error);
     }
   private:
-    std::shared_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
-  };
-  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) {
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
@@ -439,10 +535,10 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * 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__() {
+  inline std::shared_ptr<Promise<LinkedAccount>> create_std__shared_ptr_Promise_LinkedAccount__() noexcept {
     return Promise<LinkedAccount>::create();
   }
-  inline PromiseHolder<LinkedAccount> wrap_std__shared_ptr_Promise_LinkedAccount__(std::shared_ptr<Promise<LinkedAccount>> promise) {
+  inline PromiseHolder<LinkedAccount> wrap_std__shared_ptr_Promise_LinkedAccount__(std::shared_ptr<Promise<LinkedAccount>> promise) noexcept {
     return PromiseHolder<LinkedAccount>(std::move(promise));
   }
   
@@ -451,10 +547,10 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::shared_ptr<Promise<void>>`.
    */
   using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
-  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() {
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
     return Promise<void>::create();
   }
-  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) {
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
     return PromiseHolder<void>(std::move(promise));
   }
   
@@ -468,15 +564,15 @@ namespace margelo::nitro::rncandle::bridge::swift {
    */
   class Func_void_Wrapper final {
   public:
-    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_shared<std::function<void()>>(std::move(func))) {}
-    inline void call() const {
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
       _function->operator()();
     }
   private:
-    std::shared_ptr<std::function<void()>> _function;
-  };
-  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_Wrapper wrap_Func_void(Func_void value) {
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
     return Func_void_Wrapper(std::move(value));
   }
   
@@ -485,7 +581,7 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::vector<LinkedAccountStatusRef>`.
    */
   using std__vector_LinkedAccountStatusRef_ = std::vector<LinkedAccountStatusRef>;
-  inline std::vector<LinkedAccountStatusRef> create_std__vector_LinkedAccountStatusRef_(size_t size) {
+  inline std::vector<LinkedAccountStatusRef> create_std__vector_LinkedAccountStatusRef_(size_t size) noexcept {
     std::vector<LinkedAccountStatusRef> vector;
     vector.reserve(size);
     return vector;
@@ -496,61 +592,97 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::optional<double>`.
    */
   using std__optional_double_ = std::optional<double>;
-  inline std::optional<double> create_std__optional_double_(const double& value) {
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
     return std::optional<double>(value);
   }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<ACHDetails> create_std__optional_ACHDetails_(const ACHDetails& value) noexcept {
     return std::optional<ACHDetails>(value);
   }
+  inline bool has_value_std__optional_ACHDetails_(const std::optional<ACHDetails>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ACHDetails get_std__optional_ACHDetails_(const std::optional<ACHDetails>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::optional<WireDetails>
   /**
    * Specialized version of `std::optional<WireDetails>`.
    */
   using std__optional_WireDetails_ = std::optional<WireDetails>;
-  inline std::optional<WireDetails> create_std__optional_WireDetails_(const WireDetails& value) {
+  inline std::optional<WireDetails> create_std__optional_WireDetails_(const WireDetails& value) noexcept {
     return std::optional<WireDetails>(value);
   }
+  inline bool has_value_std__optional_WireDetails_(const std::optional<WireDetails>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline WireDetails get_std__optional_WireDetails_(const std::optional<WireDetails>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::optional<FiatAccount>
   /**
    * Specialized version of `std::optional<FiatAccount>`.
    */
   using std__optional_FiatAccount_ = std::optional<FiatAccount>;
-  inline std::optional<FiatAccount> create_std__optional_FiatAccount_(const FiatAccount& value) {
+  inline std::optional<FiatAccount> create_std__optional_FiatAccount_(const FiatAccount& value) noexcept {
     return std::optional<FiatAccount>(value);
   }
+  inline bool has_value_std__optional_FiatAccount_(const std::optional<FiatAccount>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline FiatAccount get_std__optional_FiatAccount_(const std::optional<FiatAccount>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::optional<MarketAccount>
   /**
    * Specialized version of `std::optional<MarketAccount>`.
    */
   using std__optional_MarketAccount_ = std::optional<MarketAccount>;
-  inline std::optional<MarketAccount> create_std__optional_MarketAccount_(const MarketAccount& value) {
+  inline std::optional<MarketAccount> create_std__optional_MarketAccount_(const MarketAccount& value) noexcept {
     return std::optional<MarketAccount>(value);
   }
+  inline bool has_value_std__optional_MarketAccount_(const std::optional<MarketAccount>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MarketAccount get_std__optional_MarketAccount_(const std::optional<MarketAccount>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::optional<TransportAccount>
   /**
    * Specialized version of `std::optional<TransportAccount>`.
    */
   using std__optional_TransportAccount_ = std::optional<TransportAccount>;
-  inline std::optional<TransportAccount> create_std__optional_TransportAccount_(const TransportAccount& value) {
+  inline std::optional<TransportAccount> create_std__optional_TransportAccount_(const TransportAccount& value) noexcept {
     return std::optional<TransportAccount>(value);
   }
+  inline bool has_value_std__optional_TransportAccount_(const std::optional<TransportAccount>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TransportAccount get_std__optional_TransportAccount_(const std::optional<TransportAccount>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::vector<AssetAccount> create_std__vector_AssetAccount_(size_t size) noexcept {
     std::vector<AssetAccount> vector;
     vector.reserve(size);
     return vector;
@@ -561,10 +693,10 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::shared_ptr<Promise<AssetAccountsResponse>>`.
    */
   using std__shared_ptr_Promise_AssetAccountsResponse__ = std::shared_ptr<Promise<AssetAccountsResponse>>;
-  inline std::shared_ptr<Promise<AssetAccountsResponse>> create_std__shared_ptr_Promise_AssetAccountsResponse__() {
+  inline std::shared_ptr<Promise<AssetAccountsResponse>> create_std__shared_ptr_Promise_AssetAccountsResponse__() noexcept {
     return Promise<AssetAccountsResponse>::create();
   }
-  inline PromiseHolder<AssetAccountsResponse> wrap_std__shared_ptr_Promise_AssetAccountsResponse__(std::shared_ptr<Promise<AssetAccountsResponse>> promise) {
+  inline PromiseHolder<AssetAccountsResponse> wrap_std__shared_ptr_Promise_AssetAccountsResponse__(std::shared_ptr<Promise<AssetAccountsResponse>> promise) noexcept {
     return PromiseHolder<AssetAccountsResponse>(std::move(promise));
   }
   
@@ -578,15 +710,15 @@ namespace margelo::nitro::rncandle::bridge::swift {
    */
   class Func_void_AssetAccountsResponse_Wrapper final {
   public:
-    explicit Func_void_AssetAccountsResponse_Wrapper(std::function<void(const AssetAccountsResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const AssetAccountsResponse& /* result */)>>(std::move(func))) {}
-    inline void call(AssetAccountsResponse result) const {
+    explicit Func_void_AssetAccountsResponse_Wrapper(std::function<void(const AssetAccountsResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const AssetAccountsResponse& /* result */)>>(std::move(func))) {}
+    inline void call(AssetAccountsResponse result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const AssetAccountsResponse& /* result */)>> _function;
-  };
-  Func_void_AssetAccountsResponse create_Func_void_AssetAccountsResponse(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_AssetAccountsResponse_Wrapper wrap_Func_void_AssetAccountsResponse(Func_void_AssetAccountsResponse value) {
+    std::unique_ptr<std::function<void(const AssetAccountsResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_AssetAccountsResponse create_Func_void_AssetAccountsResponse(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_AssetAccountsResponse_Wrapper wrap_Func_void_AssetAccountsResponse(Func_void_AssetAccountsResponse value) noexcept {
     return Func_void_AssetAccountsResponse_Wrapper(std::move(value));
   }
   
@@ -595,19 +727,25 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::optional<AssetAccountKind>`.
    */
   using std__optional_AssetAccountKind_ = std::optional<AssetAccountKind>;
-  inline std::optional<AssetAccountKind> create_std__optional_AssetAccountKind_(const AssetAccountKind& value) {
+  inline std::optional<AssetAccountKind> create_std__optional_AssetAccountKind_(const AssetAccountKind& value) noexcept {
     return std::optional<AssetAccountKind>(value);
   }
+  inline bool has_value_std__optional_AssetAccountKind_(const std::optional<AssetAccountKind>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AssetAccountKind get_std__optional_AssetAccountKind_(const std::optional<AssetAccountKind>& optional) noexcept {
+    return *optional;
+  }
   
   // 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__() {
+  inline std::shared_ptr<Promise<AssetAccount>> create_std__shared_ptr_Promise_AssetAccount__() noexcept {
     return Promise<AssetAccount>::create();
   }
-  inline PromiseHolder<AssetAccount> wrap_std__shared_ptr_Promise_AssetAccount__(std::shared_ptr<Promise<AssetAccount>> promise) {
+  inline PromiseHolder<AssetAccount> wrap_std__shared_ptr_Promise_AssetAccount__(std::shared_ptr<Promise<AssetAccount>> promise) noexcept {
     return PromiseHolder<AssetAccount>(std::move(promise));
   }
   
@@ -621,15 +759,15 @@ namespace margelo::nitro::rncandle::bridge::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 {
+    explicit Func_void_AssetAccount_Wrapper(std::function<void(const AssetAccount& /* result */)>&& func): _function(std::make_unique<std::function<void(const AssetAccount& /* result */)>>(std::move(func))) {}
+    inline void call(AssetAccount result) const noexcept {
       _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) {
+    std::unique_ptr<std::function<void(const AssetAccount& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_AssetAccount create_Func_void_AssetAccount(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_AssetAccount_Wrapper wrap_Func_void_AssetAccount(Func_void_AssetAccount value) noexcept {
     return Func_void_AssetAccount_Wrapper(std::move(value));
   }
   
@@ -638,7 +776,7 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::vector<Trade>`.
    */
   using std__vector_Trade_ = std::vector<Trade>;
-  inline std::vector<Trade> create_std__vector_Trade_(size_t size) {
+  inline std::vector<Trade> create_std__vector_Trade_(size_t size) noexcept {
     std::vector<Trade> vector;
     vector.reserve(size);
     return vector;
@@ -649,10 +787,10 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::shared_ptr<Promise<TradesResponse>>`.
    */
   using std__shared_ptr_Promise_TradesResponse__ = std::shared_ptr<Promise<TradesResponse>>;
-  inline std::shared_ptr<Promise<TradesResponse>> create_std__shared_ptr_Promise_TradesResponse__() {
+  inline std::shared_ptr<Promise<TradesResponse>> create_std__shared_ptr_Promise_TradesResponse__() noexcept {
     return Promise<TradesResponse>::create();
   }
-  inline PromiseHolder<TradesResponse> wrap_std__shared_ptr_Promise_TradesResponse__(std::shared_ptr<Promise<TradesResponse>> promise) {
+  inline PromiseHolder<TradesResponse> wrap_std__shared_ptr_Promise_TradesResponse__(std::shared_ptr<Promise<TradesResponse>> promise) noexcept {
     return PromiseHolder<TradesResponse>(std::move(promise));
   }
   
@@ -666,27 +804,57 @@ namespace margelo::nitro::rncandle::bridge::swift {
    */
   class Func_void_TradesResponse_Wrapper final {
   public:
-    explicit Func_void_TradesResponse_Wrapper(std::function<void(const TradesResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const TradesResponse& /* result */)>>(std::move(func))) {}
-    inline void call(TradesResponse result) const {
+    explicit Func_void_TradesResponse_Wrapper(std::function<void(const TradesResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const TradesResponse& /* result */)>>(std::move(func))) {}
+    inline void call(TradesResponse result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const TradesResponse& /* result */)>> _function;
-  };
-  Func_void_TradesResponse create_Func_void_TradesResponse(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_TradesResponse_Wrapper wrap_Func_void_TradesResponse(Func_void_TradesResponse value) {
+    std::unique_ptr<std::function<void(const TradesResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_TradesResponse create_Func_void_TradesResponse(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_TradesResponse_Wrapper wrap_Func_void_TradesResponse(Func_void_TradesResponse value) noexcept {
     return Func_void_TradesResponse_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<TradeAssetKind>
+  /**
+   * Specialized version of `std::optional<TradeAssetKind>`.
+   */
+  using std__optional_TradeAssetKind_ = std::optional<TradeAssetKind>;
+  inline std::optional<TradeAssetKind> create_std__optional_TradeAssetKind_(const TradeAssetKind& value) noexcept {
+    return std::optional<TradeAssetKind>(value);
+  }
+  inline bool has_value_std__optional_TradeAssetKind_(const std::optional<TradeAssetKind>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TradeAssetKind get_std__optional_TradeAssetKind_(const std::optional<TradeAssetKind>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<CounterpartyKind>
+  /**
+   * Specialized version of `std::optional<CounterpartyKind>`.
+   */
+  using std__optional_CounterpartyKind_ = std::optional<CounterpartyKind>;
+  inline std::optional<CounterpartyKind> create_std__optional_CounterpartyKind_(const CounterpartyKind& value) noexcept {
+    return std::optional<CounterpartyKind>(value);
+  }
+  inline bool has_value_std__optional_CounterpartyKind_(const std::optional<CounterpartyKind>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline CounterpartyKind get_std__optional_CounterpartyKind_(const std::optional<CounterpartyKind>& optional) noexcept {
+    return *optional;
+  }
+  
   // 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__() {
+  inline std::shared_ptr<Promise<Trade>> create_std__shared_ptr_Promise_Trade__() noexcept {
     return Promise<Trade>::create();
   }
-  inline PromiseHolder<Trade> wrap_std__shared_ptr_Promise_Trade__(std::shared_ptr<Promise<Trade>> promise) {
+  inline PromiseHolder<Trade> wrap_std__shared_ptr_Promise_Trade__(std::shared_ptr<Promise<Trade>> promise) noexcept {
     return PromiseHolder<Trade>(std::move(promise));
   }
   
@@ -700,15 +868,15 @@ namespace margelo::nitro::rncandle::bridge::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 {
+    explicit Func_void_Trade_Wrapper(std::function<void(const Trade& /* result */)>&& func): _function(std::make_unique<std::function<void(const Trade& /* result */)>>(std::move(func))) {}
+    inline void call(Trade result) const noexcept {
       _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) {
+    std::unique_ptr<std::function<void(const Trade& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_Trade create_Func_void_Trade(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_Trade_Wrapper wrap_Func_void_Trade(Func_void_Trade value) noexcept {
     return Func_void_Trade_Wrapper(std::move(value));
   }
   
@@ -717,52 +885,82 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::optional<FiatAssetRef>`.
    */
   using std__optional_FiatAssetRef_ = std::optional<FiatAssetRef>;
-  inline std::optional<FiatAssetRef> create_std__optional_FiatAssetRef_(const FiatAssetRef& value) {
+  inline std::optional<FiatAssetRef> create_std__optional_FiatAssetRef_(const FiatAssetRef& value) noexcept {
     return std::optional<FiatAssetRef>(value);
   }
+  inline bool has_value_std__optional_FiatAssetRef_(const std::optional<FiatAssetRef>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline FiatAssetRef get_std__optional_FiatAssetRef_(const std::optional<FiatAssetRef>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<MarketTradeAssetRef> create_std__optional_MarketTradeAssetRef_(const MarketTradeAssetRef& value) noexcept {
     return std::optional<MarketTradeAssetRef>(value);
   }
+  inline bool has_value_std__optional_MarketTradeAssetRef_(const std::optional<MarketTradeAssetRef>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MarketTradeAssetRef get_std__optional_MarketTradeAssetRef_(const std::optional<MarketTradeAssetRef>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<TransportAssetRef> create_std__optional_TransportAssetRef_(const TransportAssetRef& value) noexcept {
     return std::optional<TransportAssetRef>(value);
   }
+  inline bool has_value_std__optional_TransportAssetRef_(const std::optional<TransportAssetRef>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TransportAssetRef get_std__optional_TransportAssetRef_(const std::optional<TransportAssetRef>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<OtherAssetRef> create_std__optional_OtherAssetRef_(const OtherAssetRef& value) noexcept {
     return std::optional<OtherAssetRef>(value);
   }
+  inline bool has_value_std__optional_OtherAssetRef_(const std::optional<OtherAssetRef>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline OtherAssetRef get_std__optional_OtherAssetRef_(const std::optional<OtherAssetRef>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<NothingAssetRef> create_std__optional_NothingAssetRef_(const NothingAssetRef& value) noexcept {
     return std::optional<NothingAssetRef>(value);
   }
+  inline bool has_value_std__optional_NothingAssetRef_(const std::optional<NothingAssetRef>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline NothingAssetRef get_std__optional_NothingAssetRef_(const std::optional<NothingAssetRef>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::vector<TradeQuote> create_std__vector_TradeQuote_(size_t size) noexcept {
     std::vector<TradeQuote> vector;
     vector.reserve(size);
     return vector;
@@ -773,10 +971,10 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::shared_ptr<Promise<TradeQuotesResponse>>`.
    */
   using std__shared_ptr_Promise_TradeQuotesResponse__ = std::shared_ptr<Promise<TradeQuotesResponse>>;
-  inline std::shared_ptr<Promise<TradeQuotesResponse>> create_std__shared_ptr_Promise_TradeQuotesResponse__() {
+  inline std::shared_ptr<Promise<TradeQuotesResponse>> create_std__shared_ptr_Promise_TradeQuotesResponse__() noexcept {
     return Promise<TradeQuotesResponse>::create();
   }
-  inline PromiseHolder<TradeQuotesResponse> wrap_std__shared_ptr_Promise_TradeQuotesResponse__(std::shared_ptr<Promise<TradeQuotesResponse>> promise) {
+  inline PromiseHolder<TradeQuotesResponse> wrap_std__shared_ptr_Promise_TradeQuotesResponse__(std::shared_ptr<Promise<TradeQuotesResponse>> promise) noexcept {
     return PromiseHolder<TradeQuotesResponse>(std::move(promise));
   }
   
@@ -790,15 +988,15 @@ namespace margelo::nitro::rncandle::bridge::swift {
    */
   class Func_void_TradeQuotesResponse_Wrapper final {
   public:
-    explicit Func_void_TradeQuotesResponse_Wrapper(std::function<void(const TradeQuotesResponse& /* result */)>&& func): _function(std::make_shared<std::function<void(const TradeQuotesResponse& /* result */)>>(std::move(func))) {}
-    inline void call(TradeQuotesResponse result) const {
+    explicit Func_void_TradeQuotesResponse_Wrapper(std::function<void(const TradeQuotesResponse& /* result */)>&& func): _function(std::make_unique<std::function<void(const TradeQuotesResponse& /* result */)>>(std::move(func))) {}
+    inline void call(TradeQuotesResponse result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const TradeQuotesResponse& /* result */)>> _function;
-  };
-  Func_void_TradeQuotesResponse create_Func_void_TradeQuotesResponse(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_TradeQuotesResponse_Wrapper wrap_Func_void_TradeQuotesResponse(Func_void_TradeQuotesResponse value) {
+    std::unique_ptr<std::function<void(const TradeQuotesResponse& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_TradeQuotesResponse create_Func_void_TradeQuotesResponse(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_TradeQuotesResponse_Wrapper wrap_Func_void_TradeQuotesResponse(Func_void_TradeQuotesResponse value) noexcept {
     return Func_void_TradeQuotesResponse_Wrapper(std::move(value));
   }
   
@@ -807,243 +1005,182 @@ namespace margelo::nitro::rncandle::bridge::swift {
    * Specialized version of `std::optional<FiatAssetQuoteRequest>`.
    */
   using std__optional_FiatAssetQuoteRequest_ = std::optional<FiatAssetQuoteRequest>;
-  inline std::optional<FiatAssetQuoteRequest> create_std__optional_FiatAssetQuoteRequest_(const FiatAssetQuoteRequest& value) {
+  inline std::optional<FiatAssetQuoteRequest> create_std__optional_FiatAssetQuoteRequest_(const FiatAssetQuoteRequest& value) noexcept {
     return std::optional<FiatAssetQuoteRequest>(value);
   }
+  inline bool has_value_std__optional_FiatAssetQuoteRequest_(const std::optional<FiatAssetQuoteRequest>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline FiatAssetQuoteRequest get_std__optional_FiatAssetQuoteRequest_(const std::optional<FiatAssetQuoteRequest>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<MarketAssetQuoteRequest> create_std__optional_MarketAssetQuoteRequest_(const MarketAssetQuoteRequest& value) noexcept {
     return std::optional<MarketAssetQuoteRequest>(value);
   }
+  inline bool has_value_std__optional_MarketAssetQuoteRequest_(const std::optional<MarketAssetQuoteRequest>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MarketAssetQuoteRequest get_std__optional_MarketAssetQuoteRequest_(const std::optional<MarketAssetQuoteRequest>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<Coordinates> create_std__optional_Coordinates_(const Coordinates& value) noexcept {
     return std::optional<Coordinates>(value);
   }
+  inline bool has_value_std__optional_Coordinates_(const std::optional<Coordinates>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Coordinates get_std__optional_Coordinates_(const std::optional<Coordinates>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<Address> create_std__optional_Address_(const Address& value) noexcept {
     return std::optional<Address>(value);
   }
+  inline bool has_value_std__optional_Address_(const std::optional<Address>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Address get_std__optional_Address_(const std::optional<Address>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<TransportAssetQuoteRequest> create_std__optional_TransportAssetQuoteRequest_(const TransportAssetQuoteRequest& value) noexcept {
     return std::optional<TransportAssetQuoteRequest>(value);
   }
+  inline bool has_value_std__optional_TransportAssetQuoteRequest_(const std::optional<TransportAssetQuoteRequest>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TransportAssetQuoteRequest get_std__optional_TransportAssetQuoteRequest_(const std::optional<TransportAssetQuoteRequest>& optional) noexcept {
+    return *optional;
+  }
   
   // 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) {
+  inline std::optional<NothingAssetQuoteRequest> create_std__optional_NothingAssetQuoteRequest_(const NothingAssetQuoteRequest& value) noexcept {
     return std::optional<NothingAssetQuoteRequest>(value);
   }
-  
-  // pragma MARK: std::vector<std::shared_ptr<AnyMap>>
-  /**
-   * Specialized version of `std::vector<std::shared_ptr<AnyMap>>`.
-   */
-  using std__vector_std__shared_ptr_AnyMap__ = std::vector<std::shared_ptr<AnyMap>>;
-  inline std::vector<std::shared_ptr<AnyMap>> create_std__vector_std__shared_ptr_AnyMap__(size_t size) {
-    std::vector<std::shared_ptr<AnyMap>> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>>`.
-   */
-  using std__shared_ptr_Promise_std__vector_std__shared_ptr_AnyMap____ = std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>>;
-  inline std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>> create_std__shared_ptr_Promise_std__vector_std__shared_ptr_AnyMap____() {
-    return Promise<std::vector<std::shared_ptr<AnyMap>>>::create();
-  }
-  inline PromiseHolder<std::vector<std::shared_ptr<AnyMap>>> wrap_std__shared_ptr_Promise_std__vector_std__shared_ptr_AnyMap____(std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>> promise) {
-    return PromiseHolder<std::vector<std::shared_ptr<AnyMap>>>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const std::vector<std::shared_ptr<AnyMap>>& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const std::vector<std::shared_ptr<AnyMap>>&)>`.
-   */
-  using Func_void_std__vector_std__shared_ptr_AnyMap__ = std::function<void(const std::vector<std::shared_ptr<AnyMap>>& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::vector<std::shared_ptr<AnyMap>>& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__vector_std__shared_ptr_AnyMap___Wrapper final {
-  public:
-    explicit Func_void_std__vector_std__shared_ptr_AnyMap___Wrapper(std::function<void(const std::vector<std::shared_ptr<AnyMap>>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<std::shared_ptr<AnyMap>>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<std::shared_ptr<AnyMap>> result) const {
-      _function->operator()(result);
-    }
-  private:
-    std::shared_ptr<std::function<void(const std::vector<std::shared_ptr<AnyMap>>& /* result */)>> _function;
-  };
-  Func_void_std__vector_std__shared_ptr_AnyMap__ create_Func_void_std__vector_std__shared_ptr_AnyMap__(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_std__shared_ptr_AnyMap___Wrapper wrap_Func_void_std__vector_std__shared_ptr_AnyMap__(Func_void_std__vector_std__shared_ptr_AnyMap__ value) {
-    return Func_void_std__vector_std__shared_ptr_AnyMap___Wrapper(std::move(value));
+  inline bool has_value_std__optional_NothingAssetQuoteRequest_(const std::optional<NothingAssetQuoteRequest>& optional) noexcept {
+    return optional.has_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));
+  inline NothingAssetQuoteRequest get_std__optional_NothingAssetQuoteRequest_(const std::optional<NothingAssetQuoteRequest>& optional) noexcept {
+    return *optional;
   }
   
-  // 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 */)>;
+  // pragma MARK: std::shared_ptr<HybridRNCandleSpec>
   /**
-   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
+   * Specialized version of `std::shared_ptr<HybridRNCandleSpec>`.
    */
-  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>`.
-   */
-  using std__shared_ptr_margelo__nitro__rncandle__HybridRNCandleSpec_ = std::shared_ptr<margelo::nitro::rncandle::HybridRNCandleSpec>;
-  std::shared_ptr<margelo::nitro::rncandle::HybridRNCandleSpec> create_std__shared_ptr_margelo__nitro__rncandle__HybridRNCandleSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__rncandle__HybridRNCandleSpec_(std__shared_ptr_margelo__nitro__rncandle__HybridRNCandleSpec_ cppType);
+  using std__shared_ptr_HybridRNCandleSpec_ = std::shared_ptr<HybridRNCandleSpec>;
+  std::shared_ptr<HybridRNCandleSpec> create_std__shared_ptr_HybridRNCandleSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
+  void* _Nonnull get_std__shared_ptr_HybridRNCandleSpec_(std__shared_ptr_HybridRNCandleSpec_ cppType) noexcept;
   
-  // pragma MARK: std::weak_ptr<margelo::nitro::rncandle::HybridRNCandleSpec>
-  using std__weak_ptr_margelo__nitro__rncandle__HybridRNCandleSpec_ = std::weak_ptr<margelo::nitro::rncandle::HybridRNCandleSpec>;
-  inline std__weak_ptr_margelo__nitro__rncandle__HybridRNCandleSpec_ weakify_std__shared_ptr_margelo__nitro__rncandle__HybridRNCandleSpec_(const std::shared_ptr<margelo::nitro::rncandle::HybridRNCandleSpec>& strong) { return strong; }
+  // pragma MARK: std::weak_ptr<HybridRNCandleSpec>
+  using std__weak_ptr_HybridRNCandleSpec_ = std::weak_ptr<HybridRNCandleSpec>;
+  inline std__weak_ptr_HybridRNCandleSpec_ weakify_std__shared_ptr_HybridRNCandleSpec_(const std::shared_ptr<HybridRNCandleSpec>& strong) noexcept { return strong; }
   
   // pragma MARK: Result<void>
   using Result_void_ = Result<void>;
-  inline Result_void_ create_Result_void_() {
+  inline Result_void_ create_Result_void_() noexcept {
     return Result<void>::withValue();
   }
-  inline Result_void_ create_Result_void_(const std::exception_ptr& error) {
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
     return Result<void>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<LinkedAccount>>>>
   using Result_std__shared_ptr_Promise_std__vector_LinkedAccount____ = Result<std::shared_ptr<Promise<std::vector<LinkedAccount>>>>;
-  inline Result_std__shared_ptr_Promise_std__vector_LinkedAccount____ create_Result_std__shared_ptr_Promise_std__vector_LinkedAccount____(const std::shared_ptr<Promise<std::vector<LinkedAccount>>>& value) {
+  inline Result_std__shared_ptr_Promise_std__vector_LinkedAccount____ create_Result_std__shared_ptr_Promise_std__vector_LinkedAccount____(const std::shared_ptr<Promise<std::vector<LinkedAccount>>>& value) noexcept {
     return Result<std::shared_ptr<Promise<std::vector<LinkedAccount>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__vector_LinkedAccount____ create_Result_std__shared_ptr_Promise_std__vector_LinkedAccount____(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_Promise_std__vector_LinkedAccount____ create_Result_std__shared_ptr_Promise_std__vector_LinkedAccount____(const std::exception_ptr& error) noexcept {
     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) {
+  inline Result_std__shared_ptr_Promise_LinkedAccount___ create_Result_std__shared_ptr_Promise_LinkedAccount___(const std::shared_ptr<Promise<LinkedAccount>>& value) noexcept {
     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) {
+  inline Result_std__shared_ptr_Promise_LinkedAccount___ create_Result_std__shared_ptr_Promise_LinkedAccount___(const std::exception_ptr& error) noexcept {
     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) {
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
     return Result<std::shared_ptr<Promise<void>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<AssetAccountsResponse>>>
   using Result_std__shared_ptr_Promise_AssetAccountsResponse___ = Result<std::shared_ptr<Promise<AssetAccountsResponse>>>;
-  inline Result_std__shared_ptr_Promise_AssetAccountsResponse___ create_Result_std__shared_ptr_Promise_AssetAccountsResponse___(const std::shared_ptr<Promise<AssetAccountsResponse>>& value) {
+  inline Result_std__shared_ptr_Promise_AssetAccountsResponse___ create_Result_std__shared_ptr_Promise_AssetAccountsResponse___(const std::shared_ptr<Promise<AssetAccountsResponse>>& value) noexcept {
     return Result<std::shared_ptr<Promise<AssetAccountsResponse>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_AssetAccountsResponse___ create_Result_std__shared_ptr_Promise_AssetAccountsResponse___(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_Promise_AssetAccountsResponse___ create_Result_std__shared_ptr_Promise_AssetAccountsResponse___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<AssetAccountsResponse>>>::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) {
+  inline Result_std__shared_ptr_Promise_AssetAccount___ create_Result_std__shared_ptr_Promise_AssetAccount___(const std::shared_ptr<Promise<AssetAccount>>& value) noexcept {
     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) {
+  inline Result_std__shared_ptr_Promise_AssetAccount___ create_Result_std__shared_ptr_Promise_AssetAccount___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<AssetAccount>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<TradesResponse>>>
   using Result_std__shared_ptr_Promise_TradesResponse___ = Result<std::shared_ptr<Promise<TradesResponse>>>;
-  inline Result_std__shared_ptr_Promise_TradesResponse___ create_Result_std__shared_ptr_Promise_TradesResponse___(const std::shared_ptr<Promise<TradesResponse>>& value) {
+  inline Result_std__shared_ptr_Promise_TradesResponse___ create_Result_std__shared_ptr_Promise_TradesResponse___(const std::shared_ptr<Promise<TradesResponse>>& value) noexcept {
     return Result<std::shared_ptr<Promise<TradesResponse>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_TradesResponse___ create_Result_std__shared_ptr_Promise_TradesResponse___(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_Promise_TradesResponse___ create_Result_std__shared_ptr_Promise_TradesResponse___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<TradesResponse>>>::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) {
+  inline Result_std__shared_ptr_Promise_Trade___ create_Result_std__shared_ptr_Promise_Trade___(const std::shared_ptr<Promise<Trade>>& value) noexcept {
     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) {
+  inline Result_std__shared_ptr_Promise_Trade___ create_Result_std__shared_ptr_Promise_Trade___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<Trade>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<TradeQuotesResponse>>>
   using Result_std__shared_ptr_Promise_TradeQuotesResponse___ = Result<std::shared_ptr<Promise<TradeQuotesResponse>>>;
-  inline Result_std__shared_ptr_Promise_TradeQuotesResponse___ create_Result_std__shared_ptr_Promise_TradeQuotesResponse___(const std::shared_ptr<Promise<TradeQuotesResponse>>& value) {
+  inline Result_std__shared_ptr_Promise_TradeQuotesResponse___ create_Result_std__shared_ptr_Promise_TradeQuotesResponse___(const std::shared_ptr<Promise<TradeQuotesResponse>>& value) noexcept {
     return Result<std::shared_ptr<Promise<TradeQuotesResponse>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_TradeQuotesResponse___ create_Result_std__shared_ptr_Promise_TradeQuotesResponse___(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_Promise_TradeQuotesResponse___ create_Result_std__shared_ptr_Promise_TradeQuotesResponse___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<TradeQuotesResponse>>>::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) {
-    return Result<std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>>>::withValue(value);
-  }
-  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