react-native-candle 19.0.12-beta → 40.0.8-beta

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

@@ -54,6 +54,20 @@ namespace margelo::nitro::rncandle { struct FiatAssetRef; }
 namespace margelo::nitro::rncandle { struct FiatAsset; }
 // Forward declaration of `FinancialAccountKind` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class FinancialAccountKind; }
+// Forward declaration of `FriendRequestAssetDirection` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class FriendRequestAssetDirection; }
+// Forward declaration of `FriendRequestAssetQuoteRequestAction` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class FriendRequestAssetQuoteRequestAction; }
+// Forward declaration of `FriendRequestAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FriendRequestAssetQuoteRequest; }
+// Forward declaration of `FriendRequestAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FriendRequestAssetRef; }
+// Forward declaration of `FriendRequestAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FriendRequestAsset; }
+// Forward declaration of `HostedAuthorizationCallback` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct HostedAuthorizationCallback; }
+// Forward declaration of `HostedAuthorizationRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct HostedAuthorizationRequest; }
 // Forward declaration of `HybridRNCandleSpec` to properly resolve imports.
 namespace margelo::nitro::rncandle { class HybridRNCandleSpec; }
 // Forward declaration of `InactiveLinkedAccountDetails` to properly resolve imports.
@@ -72,6 +86,14 @@ namespace margelo::nitro::rncandle { struct MerchantCounterpartyQuoteRequest; }
 namespace margelo::nitro::rncandle { struct MerchantCounterparty; }
 // Forward declaration of `MerchantLocation` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct MerchantLocation; }
+// Forward declaration of `MessageThreadAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadAssetQuoteRequest; }
+// Forward declaration of `MessageThreadAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadAssetRef; }
+// Forward declaration of `MessageThreadAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadAsset; }
+// Forward declaration of `MessageThreadMessage` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadMessage; }
 // Forward declaration of `NothingAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct NothingAssetQuoteRequest; }
 // Forward declaration of `NothingAssetRef` to properly resolve imports.
@@ -88,8 +110,10 @@ namespace margelo::nitro::rncandle { struct OtherAsset; }
 namespace margelo::nitro::rncandle { struct ServiceCounterpartyQuoteRequest; }
 // Forward declaration of `ServiceCounterparty` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct ServiceCounterparty; }
+// Forward declaration of `ServiceID` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class ServiceID; }
 // Forward declaration of `Service` to properly resolve imports.
-namespace margelo::nitro::rncandle { enum class Service; }
+namespace margelo::nitro::rncandle { struct Service; }
 // Forward declaration of `StockAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct StockAccount; }
 // Forward declaration of `StockAssetQuoteRequest` to properly resolve imports.
@@ -161,6 +185,13 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include "FiatAssetQuoteRequest.hpp"
 #include "FiatAssetRef.hpp"
 #include "FinancialAccountKind.hpp"
+#include "FriendRequestAsset.hpp"
+#include "FriendRequestAssetDirection.hpp"
+#include "FriendRequestAssetQuoteRequest.hpp"
+#include "FriendRequestAssetQuoteRequestAction.hpp"
+#include "FriendRequestAssetRef.hpp"
+#include "HostedAuthorizationCallback.hpp"
+#include "HostedAuthorizationRequest.hpp"
 #include "HybridRNCandleSpec.hpp"
 #include "InactiveLinkedAccountDetails.hpp"
 #include "LinkedAccount.hpp"
@@ -170,6 +201,10 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include "MerchantCounterparty.hpp"
 #include "MerchantCounterpartyQuoteRequest.hpp"
 #include "MerchantLocation.hpp"
+#include "MessageThreadAsset.hpp"
+#include "MessageThreadAssetQuoteRequest.hpp"
+#include "MessageThreadAssetRef.hpp"
+#include "MessageThreadMessage.hpp"
 #include "NothingAsset.hpp"
 #include "NothingAssetQuoteRequest.hpp"
 #include "NothingAssetRef.hpp"
@@ -179,6 +214,7 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include "Service.hpp"
 #include "ServiceCounterparty.hpp"
 #include "ServiceCounterpartyQuoteRequest.hpp"
+#include "ServiceID.hpp"
 #include "StockAccount.hpp"
 #include "StockAsset.hpp"
 #include "StockAssetQuoteRequest.hpp"
@@ -216,29 +252,29 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
  */
 namespace margelo::nitro::rncandle::bridge::swift {
 
-  // pragma MARK: std::vector<Service>
+  // pragma MARK: std::vector<ServiceID>
   /**
-   * Specialized version of `std::vector<Service>`.
+   * Specialized version of `std::vector<ServiceID>`.
    */
-  using std__vector_Service_ = std::vector<Service>;
-  inline std::vector<Service> create_std__vector_Service_(size_t size) noexcept {
-    std::vector<Service> vector;
+  using std__vector_ServiceID_ = std::vector<ServiceID>;
+  inline std::vector<ServiceID> create_std__vector_ServiceID_(size_t size) noexcept {
+    std::vector<ServiceID> vector;
     vector.reserve(size);
     return vector;
   }
   
-  // pragma MARK: std::optional<std::vector<Service>>
+  // pragma MARK: std::optional<std::vector<ServiceID>>
   /**
-   * Specialized version of `std::optional<std::vector<Service>>`.
+   * Specialized version of `std::optional<std::vector<ServiceID>>`.
    */
-  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) noexcept {
-    return std::optional<std::vector<Service>>(value);
+  using std__optional_std__vector_ServiceID__ = std::optional<std::vector<ServiceID>>;
+  inline std::optional<std::vector<ServiceID>> create_std__optional_std__vector_ServiceID__(const std::vector<ServiceID>& value) noexcept {
+    return std::optional<std::vector<ServiceID>>(value);
   }
-  inline bool has_value_std__optional_std__vector_Service__(const std::optional<std::vector<Service>>& optional) noexcept {
+  inline bool has_value_std__optional_std__vector_ServiceID__(const std::optional<std::vector<ServiceID>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::vector<Service> get_std__optional_std__vector_Service__(const std::optional<std::vector<Service>>& optional) noexcept {
+  inline std::vector<ServiceID> get_std__optional_std__vector_ServiceID__(const std::optional<std::vector<ServiceID>>& optional) noexcept {
     return optional.value();
   }
   
@@ -302,22 +338,22 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::function<void(const LinkedAccount& /* account */)>
+  // pragma MARK: std::function<void(const LinkedAccount& /* linkedAccount */)>
   /**
    * Specialized version of `std::function<void(const LinkedAccount&)>`.
    */
-  using Func_void_LinkedAccount = std::function<void(const LinkedAccount& /* account */)>;
+  using Func_void_LinkedAccount = std::function<void(const LinkedAccount& /* linkedAccount */)>;
   /**
-   * Wrapper class for a `std::function<void(const LinkedAccount& / * account * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const LinkedAccount& / * linkedAccount * /)>`, this can be used from Swift.
    */
   class Func_void_LinkedAccount_Wrapper final {
   public:
-    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);
+    explicit Func_void_LinkedAccount_Wrapper(std::function<void(const LinkedAccount& /* linkedAccount */)>&& func): _function(std::make_unique<std::function<void(const LinkedAccount& /* linkedAccount */)>>(std::move(func))) {}
+    inline void call(LinkedAccount linkedAccount) const noexcept {
+      _function->operator()(linkedAccount);
     }
   private:
-    std::unique_ptr<std::function<void(const LinkedAccount& /* account */)>> _function;
+    std::unique_ptr<std::function<void(const LinkedAccount& /* linkedAccount */)>> _function;
   } SWIFT_NONCOPYABLE;
   Func_void_LinkedAccount create_Func_void_LinkedAccount(void* NON_NULL swiftClosureWrapper) noexcept;
   inline Func_void_LinkedAccount_Wrapper wrap_Func_void_LinkedAccount(Func_void_LinkedAccount value) noexcept {
@@ -399,6 +435,47 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::vector<MessageThreadMessage>
+  /**
+   * Specialized version of `std::vector<MessageThreadMessage>`.
+   */
+  using std__vector_MessageThreadMessage_ = std::vector<MessageThreadMessage>;
+  inline std::vector<MessageThreadMessage> create_std__vector_MessageThreadMessage_(size_t size) noexcept {
+    std::vector<MessageThreadMessage> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<MessageThreadAsset>
+  /**
+   * Specialized version of `std::optional<MessageThreadAsset>`.
+   */
+  using std__optional_MessageThreadAsset_ = std::optional<MessageThreadAsset>;
+  inline std::optional<MessageThreadAsset> create_std__optional_MessageThreadAsset_(const MessageThreadAsset& value) noexcept {
+    return std::optional<MessageThreadAsset>(value);
+  }
+  inline bool has_value_std__optional_MessageThreadAsset_(const std::optional<MessageThreadAsset>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MessageThreadAsset get_std__optional_MessageThreadAsset_(const std::optional<MessageThreadAsset>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<FriendRequestAsset>
+  /**
+   * Specialized version of `std::optional<FriendRequestAsset>`.
+   */
+  using std__optional_FriendRequestAsset_ = std::optional<FriendRequestAsset>;
+  inline std::optional<FriendRequestAsset> create_std__optional_FriendRequestAsset_(const FriendRequestAsset& value) noexcept {
+    return std::optional<FriendRequestAsset>(value);
+  }
+  inline bool has_value_std__optional_FriendRequestAsset_(const std::optional<FriendRequestAsset>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline FriendRequestAsset get_std__optional_FriendRequestAsset_(const std::optional<FriendRequestAsset>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<OtherAsset>
   /**
    * Specialized version of `std::optional<OtherAsset>`.
@@ -1033,6 +1110,36 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::optional<MessageThreadAssetRef>
+  /**
+   * Specialized version of `std::optional<MessageThreadAssetRef>`.
+   */
+  using std__optional_MessageThreadAssetRef_ = std::optional<MessageThreadAssetRef>;
+  inline std::optional<MessageThreadAssetRef> create_std__optional_MessageThreadAssetRef_(const MessageThreadAssetRef& value) noexcept {
+    return std::optional<MessageThreadAssetRef>(value);
+  }
+  inline bool has_value_std__optional_MessageThreadAssetRef_(const std::optional<MessageThreadAssetRef>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MessageThreadAssetRef get_std__optional_MessageThreadAssetRef_(const std::optional<MessageThreadAssetRef>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<FriendRequestAssetRef>
+  /**
+   * Specialized version of `std::optional<FriendRequestAssetRef>`.
+   */
+  using std__optional_FriendRequestAssetRef_ = std::optional<FriendRequestAssetRef>;
+  inline std::optional<FriendRequestAssetRef> create_std__optional_FriendRequestAssetRef_(const FriendRequestAssetRef& value) noexcept {
+    return std::optional<FriendRequestAssetRef>(value);
+  }
+  inline bool has_value_std__optional_FriendRequestAssetRef_(const std::optional<FriendRequestAssetRef>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline FriendRequestAssetRef get_std__optional_FriendRequestAssetRef_(const std::optional<FriendRequestAssetRef>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<OtherAssetRef>
   /**
    * Specialized version of `std::optional<OtherAssetRef>`.
@@ -1213,6 +1320,36 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return optional.value();
   }
   
+  // pragma MARK: std::optional<MessageThreadAssetQuoteRequest>
+  /**
+   * Specialized version of `std::optional<MessageThreadAssetQuoteRequest>`.
+   */
+  using std__optional_MessageThreadAssetQuoteRequest_ = std::optional<MessageThreadAssetQuoteRequest>;
+  inline std::optional<MessageThreadAssetQuoteRequest> create_std__optional_MessageThreadAssetQuoteRequest_(const MessageThreadAssetQuoteRequest& value) noexcept {
+    return std::optional<MessageThreadAssetQuoteRequest>(value);
+  }
+  inline bool has_value_std__optional_MessageThreadAssetQuoteRequest_(const std::optional<MessageThreadAssetQuoteRequest>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MessageThreadAssetQuoteRequest get_std__optional_MessageThreadAssetQuoteRequest_(const std::optional<MessageThreadAssetQuoteRequest>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<FriendRequestAssetQuoteRequest>
+  /**
+   * Specialized version of `std::optional<FriendRequestAssetQuoteRequest>`.
+   */
+  using std__optional_FriendRequestAssetQuoteRequest_ = std::optional<FriendRequestAssetQuoteRequest>;
+  inline std::optional<FriendRequestAssetQuoteRequest> create_std__optional_FriendRequestAssetQuoteRequest_(const FriendRequestAssetQuoteRequest& value) noexcept {
+    return std::optional<FriendRequestAssetQuoteRequest>(value);
+  }
+  inline bool has_value_std__optional_FriendRequestAssetQuoteRequest_(const std::optional<FriendRequestAssetQuoteRequest>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline FriendRequestAssetQuoteRequest get_std__optional_FriendRequestAssetQuoteRequest_(const std::optional<FriendRequestAssetQuoteRequest>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<NothingAssetQuoteRequest>
   /**
    * Specialized version of `std::optional<NothingAssetQuoteRequest>`.
@@ -1395,5 +1532,32 @@ namespace margelo::nitro::rncandle::bridge::swift {
   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::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
+    return Result<std::string>::withError(error);
+  }
+  
+  // pragma MARK: Result<HostedAuthorizationRequest>
+  using Result_HostedAuthorizationRequest_ = Result<HostedAuthorizationRequest>;
+  inline Result_HostedAuthorizationRequest_ create_Result_HostedAuthorizationRequest_(const HostedAuthorizationRequest& value) noexcept {
+    return Result<HostedAuthorizationRequest>::withValue(value);
+  }
+  inline Result_HostedAuthorizationRequest_ create_Result_HostedAuthorizationRequest_(const std::exception_ptr& error) noexcept {
+    return Result<HostedAuthorizationRequest>::withError(error);
+  }
+  
+  // pragma MARK: Result<HostedAuthorizationCallback>
+  using Result_HostedAuthorizationCallback_ = Result<HostedAuthorizationCallback>;
+  inline Result_HostedAuthorizationCallback_ create_Result_HostedAuthorizationCallback_(const HostedAuthorizationCallback& value) noexcept {
+    return Result<HostedAuthorizationCallback>::withValue(value);
+  }
+  inline Result_HostedAuthorizationCallback_ create_Result_HostedAuthorizationCallback_(const std::exception_ptr& error) noexcept {
+    return Result<HostedAuthorizationCallback>::withError(error);
+  }
 
 } // namespace margelo::nitro::rncandle::bridge::swift

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

@@ -58,6 +58,20 @@ namespace margelo::nitro::rncandle { struct FiatAssetRef; }
 namespace margelo::nitro::rncandle { struct FiatAsset; }
 // Forward declaration of `FinancialAccountKind` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class FinancialAccountKind; }
+// Forward declaration of `FriendRequestAssetDirection` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class FriendRequestAssetDirection; }
+// Forward declaration of `FriendRequestAssetQuoteRequestAction` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class FriendRequestAssetQuoteRequestAction; }
+// Forward declaration of `FriendRequestAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FriendRequestAssetQuoteRequest; }
+// Forward declaration of `FriendRequestAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FriendRequestAssetRef; }
+// Forward declaration of `FriendRequestAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FriendRequestAsset; }
+// Forward declaration of `HostedAuthorizationCallback` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct HostedAuthorizationCallback; }
+// Forward declaration of `HostedAuthorizationRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct HostedAuthorizationRequest; }
 // Forward declaration of `HybridRNCandleSpec` to properly resolve imports.
 namespace margelo::nitro::rncandle { class HybridRNCandleSpec; }
 // Forward declaration of `InactiveLinkedAccountDetails` to properly resolve imports.
@@ -78,6 +92,14 @@ namespace margelo::nitro::rncandle { struct MerchantCounterpartyQuoteRequest; }
 namespace margelo::nitro::rncandle { struct MerchantCounterparty; }
 // Forward declaration of `MerchantLocation` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct MerchantLocation; }
+// Forward declaration of `MessageThreadAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadAssetQuoteRequest; }
+// Forward declaration of `MessageThreadAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadAssetRef; }
+// Forward declaration of `MessageThreadAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadAsset; }
+// Forward declaration of `MessageThreadMessage` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadMessage; }
 // Forward declaration of `NothingAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct NothingAssetQuoteRequest; }
 // Forward declaration of `NothingAssetRef` to properly resolve imports.
@@ -98,8 +120,10 @@ namespace margelo::nitro::rncandle { enum class PresentationStyle; }
 namespace margelo::nitro::rncandle { struct ServiceCounterpartyQuoteRequest; }
 // Forward declaration of `ServiceCounterparty` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct ServiceCounterparty; }
+// Forward declaration of `ServiceID` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class ServiceID; }
 // Forward declaration of `Service` to properly resolve imports.
-namespace margelo::nitro::rncandle { enum class Service; }
+namespace margelo::nitro::rncandle { struct Service; }
 // Forward declaration of `StockAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct StockAccount; }
 // Forward declaration of `StockAssetQuoteRequest` to properly resolve imports.
@@ -179,6 +203,13 @@ namespace margelo::nitro::rncandle { struct WireDetails; }
 #include "FiatAssetQuoteRequest.hpp"
 #include "FiatAssetRef.hpp"
 #include "FinancialAccountKind.hpp"
+#include "FriendRequestAsset.hpp"
+#include "FriendRequestAssetDirection.hpp"
+#include "FriendRequestAssetQuoteRequest.hpp"
+#include "FriendRequestAssetQuoteRequestAction.hpp"
+#include "FriendRequestAssetRef.hpp"
+#include "HostedAuthorizationCallback.hpp"
+#include "HostedAuthorizationRequest.hpp"
 #include "HybridRNCandleSpec.hpp"
 #include "InactiveLinkedAccountDetails.hpp"
 #include "LinkedAccount.hpp"
@@ -189,6 +220,10 @@ namespace margelo::nitro::rncandle { struct WireDetails; }
 #include "MerchantCounterparty.hpp"
 #include "MerchantCounterpartyQuoteRequest.hpp"
 #include "MerchantLocation.hpp"
+#include "MessageThreadAsset.hpp"
+#include "MessageThreadAssetQuoteRequest.hpp"
+#include "MessageThreadAssetRef.hpp"
+#include "MessageThreadMessage.hpp"
 #include "NothingAsset.hpp"
 #include "NothingAssetQuoteRequest.hpp"
 #include "NothingAssetRef.hpp"
@@ -200,6 +235,7 @@ namespace margelo::nitro::rncandle { struct WireDetails; }
 #include "Service.hpp"
 #include "ServiceCounterparty.hpp"
 #include "ServiceCounterpartyQuoteRequest.hpp"
+#include "ServiceID.hpp"
 #include "StockAccount.hpp"
 #include "StockAsset.hpp"
 #include "StockAssetQuoteRequest.hpp"

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

@@ -12,14 +12,16 @@
 // Forward declaration of `HybridRNCandleSpec_cxx` to properly resolve imports.
 namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 
-// Forward declaration of `Service` to properly resolve imports.
-namespace margelo::nitro::rncandle { enum class Service; }
+// Forward declaration of `ServiceID` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class ServiceID; }
 // Forward declaration of `PresentationBackground` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class PresentationBackground; }
 // Forward declaration of `PresentationStyle` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class PresentationStyle; }
 // Forward declaration of `LinkedAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct LinkedAccount; }
+// Forward declaration of `Service` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Service; }
 // Forward declaration of `LinkedAccountDetails` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct LinkedAccountDetails; }
 // Forward declaration of `ActiveLinkedAccountDetails` to properly resolve imports.
@@ -46,6 +48,16 @@ namespace margelo::nitro::rncandle { struct Coordinates; }
 namespace margelo::nitro::rncandle { struct Address; }
 // Forward declaration of `EventAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct EventAsset; }
+// Forward declaration of `MessageThreadAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadAsset; }
+// Forward declaration of `MessageThreadMessage` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadMessage; }
+// Forward declaration of `FriendRequestAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FriendRequestAsset; }
+// Forward declaration of `FriendRequestAssetDirection` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class FriendRequestAssetDirection; }
+// Forward declaration of `UserCounterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct UserCounterparty; }
 // Forward declaration of `OtherAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct OtherAsset; }
 // Forward declaration of `NothingAsset` to properly resolve imports.
@@ -56,8 +68,6 @@ namespace margelo::nitro::rncandle { struct Counterparty; }
 namespace margelo::nitro::rncandle { struct MerchantCounterparty; }
 // Forward declaration of `MerchantLocation` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct MerchantLocation; }
-// Forward declaration of `UserCounterparty` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct UserCounterparty; }
 // Forward declaration of `ServiceCounterparty` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct ServiceCounterparty; }
 // Forward declaration of `TradeExecutionResult` to properly resolve imports.
@@ -122,6 +132,10 @@ namespace margelo::nitro::rncandle { struct StockAssetRef; }
 namespace margelo::nitro::rncandle { struct TransportAssetRef; }
 // Forward declaration of `EventAssetRef` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct EventAssetRef; }
+// Forward declaration of `MessageThreadAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadAssetRef; }
+// Forward declaration of `FriendRequestAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FriendRequestAssetRef; }
 // Forward declaration of `OtherAssetRef` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct OtherAssetRef; }
 // Forward declaration of `NothingAssetRef` to properly resolve imports.
@@ -142,6 +156,12 @@ namespace margelo::nitro::rncandle { struct StockAssetQuoteRequest; }
 namespace margelo::nitro::rncandle { struct TransportAssetQuoteRequest; }
 // Forward declaration of `EventAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct EventAssetQuoteRequest; }
+// Forward declaration of `MessageThreadAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MessageThreadAssetQuoteRequest; }
+// Forward declaration of `FriendRequestAssetQuoteRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FriendRequestAssetQuoteRequest; }
+// Forward declaration of `FriendRequestAssetQuoteRequestAction` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class FriendRequestAssetQuoteRequestAction; }
 // Forward declaration of `NothingAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct NothingAssetQuoteRequest; }
 // Forward declaration of `OtherAssetQuoteRequest` to properly resolve imports.
@@ -154,8 +174,12 @@ namespace margelo::nitro::rncandle { struct UserCounterpartyQuoteRequest; }
 namespace margelo::nitro::rncandle { struct MerchantCounterpartyQuoteRequest; }
 // Forward declaration of `ServiceCounterpartyQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct ServiceCounterpartyQuoteRequest; }
+// Forward declaration of `HostedAuthorizationRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct HostedAuthorizationRequest; }
+// Forward declaration of `HostedAuthorizationCallback` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct HostedAuthorizationCallback; }
 
-#include "Service.hpp"
+#include "ServiceID.hpp"
 #include <vector>
 #include <optional>
 #include <string>
@@ -163,6 +187,7 @@ namespace margelo::nitro::rncandle { struct ServiceCounterpartyQuoteRequest; }
 #include "PresentationStyle.hpp"
 #include "LinkedAccount.hpp"
 #include <functional>
+#include "Service.hpp"
 #include "LinkedAccountDetails.hpp"
 #include "ActiveLinkedAccountDetails.hpp"
 #include "InactiveLinkedAccountDetails.hpp"
@@ -176,12 +201,16 @@ namespace margelo::nitro::rncandle { struct ServiceCounterpartyQuoteRequest; }
 #include "Coordinates.hpp"
 #include "Address.hpp"
 #include "EventAsset.hpp"
+#include "MessageThreadAsset.hpp"
+#include "MessageThreadMessage.hpp"
+#include "FriendRequestAsset.hpp"
+#include "FriendRequestAssetDirection.hpp"
+#include "UserCounterparty.hpp"
 #include "OtherAsset.hpp"
 #include "NothingAsset.hpp"
 #include "Counterparty.hpp"
 #include "MerchantCounterparty.hpp"
 #include "MerchantLocation.hpp"
-#include "UserCounterparty.hpp"
 #include "ServiceCounterparty.hpp"
 #include "TradeExecutionResult.hpp"
 #include "Trade.hpp"
@@ -215,6 +244,8 @@ namespace margelo::nitro::rncandle { struct ServiceCounterpartyQuoteRequest; }
 #include "StockAssetRef.hpp"
 #include "TransportAssetRef.hpp"
 #include "EventAssetRef.hpp"
+#include "MessageThreadAssetRef.hpp"
+#include "FriendRequestAssetRef.hpp"
 #include "OtherAssetRef.hpp"
 #include "NothingAssetRef.hpp"
 #include "TradeQuotesResponse.hpp"
@@ -225,12 +256,17 @@ namespace margelo::nitro::rncandle { struct ServiceCounterpartyQuoteRequest; }
 #include "StockAssetQuoteRequest.hpp"
 #include "TransportAssetQuoteRequest.hpp"
 #include "EventAssetQuoteRequest.hpp"
+#include "MessageThreadAssetQuoteRequest.hpp"
+#include "FriendRequestAssetQuoteRequest.hpp"
+#include "FriendRequestAssetQuoteRequestAction.hpp"
 #include "NothingAssetQuoteRequest.hpp"
 #include "OtherAssetQuoteRequest.hpp"
 #include "CounterpartyQuoteRequest.hpp"
 #include "UserCounterpartyQuoteRequest.hpp"
 #include "MerchantCounterpartyQuoteRequest.hpp"
 #include "ServiceCounterpartyQuoteRequest.hpp"
+#include "HostedAuthorizationRequest.hpp"
+#include "HostedAuthorizationCallback.hpp"
 
 #include "ReactNativeCandle-Swift-Cxx-Umbrella.hpp"
 
@@ -282,8 +318,8 @@ namespace margelo::nitro::rncandle {
 
   public:
     // Methods
-    inline void candleLinkSheet(bool isPresented, const std::optional<std::vector<Service>>& services, double cornerRadius, const std::optional<std::string>& customerName, bool showDynamicLoading, PresentationBackground presentationBackground, PresentationStyle presentationStyle, const std::function<void(const LinkedAccount& /* account */)>& onSuccess) override {
-      auto __result = _swiftPart.candleLinkSheet(std::forward<decltype(isPresented)>(isPresented), services, std::forward<decltype(cornerRadius)>(cornerRadius), customerName, std::forward<decltype(showDynamicLoading)>(showDynamicLoading), static_cast<int>(presentationBackground), static_cast<int>(presentationStyle), onSuccess);
+    inline void candleLinkSheet(bool isPresented, const std::optional<std::vector<ServiceID>>& services, bool showSandbox, double cornerRadius, const std::optional<std::string>& customerName, bool showDynamicLoading, PresentationBackground presentationBackground, PresentationStyle presentationStyle, const std::function<void(const LinkedAccount& /* linkedAccount */)>& onSuccess) override {
+      auto __result = _swiftPart.candleLinkSheet(std::forward<decltype(isPresented)>(isPresented), services, std::forward<decltype(showSandbox)>(showSandbox), std::forward<decltype(cornerRadius)>(cornerRadius), customerName, std::forward<decltype(showDynamicLoading)>(showDynamicLoading), static_cast<int>(presentationBackground), static_cast<int>(presentationStyle), onSuccess);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -294,8 +330,8 @@ namespace margelo::nitro::rncandle {
         std::rethrow_exception(__result.error());
       }
     }
-    inline void initialize(const std::string& appKey, const std::string& appSecret, const std::optional<std::string>& accessGroup) override {
-      auto __result = _swiftPart.initialize(appKey, appSecret, accessGroup);
+    inline void initialize(const std::string& clientID, const std::optional<std::string>& accessGroup) override {
+      auto __result = _swiftPart.initialize(clientID, accessGroup);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -380,16 +416,40 @@ namespace margelo::nitro::rncandle {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<void>> createUser(const std::string& appUserID) override {
-      auto __result = _swiftPart.createUser(appUserID);
+    inline std::string hostedAuthorizationUrl(const std::string& redirectUri, const std::string& state, const std::string& codeChallenge, const std::string& grantPackagePublicKey) override {
+      auto __result = _swiftPart.hostedAuthorizationUrl(redirectUri, state, codeChallenge, grantPackagePublicKey);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline HostedAuthorizationRequest makeHostedAuthorizationRequest(const std::string& redirectUri, const std::optional<std::string>& state) override {
+      auto __result = _swiftPart.makeHostedAuthorizationRequest(redirectUri, state);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline HostedAuthorizationCallback parseHostedAuthorizationCallback(const std::string& callbackUrl) override {
+      auto __result = _swiftPart.parseHostedAuthorizationCallback(callbackUrl);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> completeHostedAuthorization(const std::string& callbackUrl) override {
+      auto __result = _swiftPart.completeHostedAuthorization(callbackUrl);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<void>> deleteUser() override {
-      auto __result = _swiftPart.deleteUser();
+    inline std::shared_ptr<Promise<void>> signOut() override {
+      auto __result = _swiftPart.signOut();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

package/nitrogen/generated/ios/swift/FriendRequestAsset.swift

@@ -0,0 +1,67 @@
+///
+/// FriendRequestAsset.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `FriendRequestAsset`, backed by a C++ struct.
+ */
+public typealias FriendRequestAsset = margelo.nitro.rncandle.FriendRequestAsset
+
+public extension FriendRequestAsset {
+  private typealias bridge = margelo.nitro.rncandle.bridge.swift
+
+  /**
+   * Create a new instance of `FriendRequestAsset`.
+   */
+  init(assetKind: String, serviceTradeID: String?, direction: FriendRequestAssetDirection, user: UserCounterparty, linkedAccountID: String, service: Service) {
+    self.init(std.string(assetKind), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = serviceTradeID {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), direction, user, std.string(linkedAccountID), service)
+  }
+
+  @inline(__always)
+  var assetKind: String {
+    return String(self.__assetKind)
+  }
+  
+  @inline(__always)
+  var serviceTradeID: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__serviceTradeID) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__serviceTradeID)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var direction: FriendRequestAssetDirection {
+    return self.__direction
+  }
+  
+  @inline(__always)
+  var user: UserCounterparty {
+    return self.__user
+  }
+  
+  @inline(__always)
+  var linkedAccountID: String {
+    return String(self.__linkedAccountID)
+  }
+  
+  @inline(__always)
+  var service: Service {
+    return self.__service
+  }
+}