react-native-candle 0.1.43 → 0.1.44

package/nitrogen/generated/shared/c++/FiatMarketAccountKind.hpp

@@ -40,30 +40,28 @@ namespace margelo::nitro::rncandle {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::rncandle;
-
   // C++ FiatMarketAccountKind <> JS FiatMarketAccountKind (union)
   template <>
-  struct JSIConverter<FiatMarketAccountKind> final {
-    static inline FiatMarketAccountKind fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::rncandle::FiatMarketAccountKind> final {
+    static inline margelo::nitro::rncandle::FiatMarketAccountKind fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("individual"): return FiatMarketAccountKind::INDIVIDUAL;
-        case hashString("joint"): return FiatMarketAccountKind::JOINT;
-        case hashString("traditionalIRA"): return FiatMarketAccountKind::TRADITIONALIRA;
-        case hashString("rothIRA"): return FiatMarketAccountKind::ROTHIRA;
-        case hashString("business"): return FiatMarketAccountKind::BUSINESS;
+        case hashString("individual"): return margelo::nitro::rncandle::FiatMarketAccountKind::INDIVIDUAL;
+        case hashString("joint"): return margelo::nitro::rncandle::FiatMarketAccountKind::JOINT;
+        case hashString("traditionalIRA"): return margelo::nitro::rncandle::FiatMarketAccountKind::TRADITIONALIRA;
+        case hashString("rothIRA"): return margelo::nitro::rncandle::FiatMarketAccountKind::ROTHIRA;
+        case hashString("business"): return margelo::nitro::rncandle::FiatMarketAccountKind::BUSINESS;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum FiatMarketAccountKind - invalid value!");
       }
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, FiatMarketAccountKind arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::rncandle::FiatMarketAccountKind arg) {
       switch (arg) {
-        case FiatMarketAccountKind::INDIVIDUAL: return JSIConverter<std::string>::toJSI(runtime, "individual");
-        case FiatMarketAccountKind::JOINT: return JSIConverter<std::string>::toJSI(runtime, "joint");
-        case FiatMarketAccountKind::TRADITIONALIRA: return JSIConverter<std::string>::toJSI(runtime, "traditionalIRA");
-        case FiatMarketAccountKind::ROTHIRA: return JSIConverter<std::string>::toJSI(runtime, "rothIRA");
-        case FiatMarketAccountKind::BUSINESS: return JSIConverter<std::string>::toJSI(runtime, "business");
+        case margelo::nitro::rncandle::FiatMarketAccountKind::INDIVIDUAL: return JSIConverter<std::string>::toJSI(runtime, "individual");
+        case margelo::nitro::rncandle::FiatMarketAccountKind::JOINT: return JSIConverter<std::string>::toJSI(runtime, "joint");
+        case margelo::nitro::rncandle::FiatMarketAccountKind::TRADITIONALIRA: return JSIConverter<std::string>::toJSI(runtime, "traditionalIRA");
+        case margelo::nitro::rncandle::FiatMarketAccountKind::ROTHIRA: return JSIConverter<std::string>::toJSI(runtime, "rothIRA");
+        case margelo::nitro::rncandle::FiatMarketAccountKind::BUSINESS: return JSIConverter<std::string>::toJSI(runtime, "business");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert FiatMarketAccountKind to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");

package/nitrogen/generated/shared/c++/HybridRNCandleSpec.cpp

@@ -25,9 +25,8 @@ namespace margelo::nitro::rncandle {
       prototype.registerHybridMethod("getTrades", &HybridRNCandleSpec::getTrades);
       prototype.registerHybridMethod("getTrade", &HybridRNCandleSpec::getTrade);
       prototype.registerHybridMethod("getTradeQuotes", &HybridRNCandleSpec::getTradeQuotes);
+      prototype.registerHybridMethod("createUser", &HybridRNCandleSpec::createUser);
       prototype.registerHybridMethod("deleteUser", &HybridRNCandleSpec::deleteUser);
-      prototype.registerHybridMethod("getAvailableTools", &HybridRNCandleSpec::getAvailableTools);
-      prototype.registerHybridMethod("executeTool", &HybridRNCandleSpec::executeTool);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridRNCandleSpec.hpp

@@ -25,60 +25,51 @@ namespace margelo::nitro::rncandle { struct LinkedAccount; }
 namespace margelo::nitro::rncandle { struct TradeQuote; }
 // Forward declaration of `TradeExecutionResult` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeExecutionResult; }
-// Forward declaration of `AppUser` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct AppUser; }
 // Forward declaration of `LinkedAccountRef` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct LinkedAccountRef; }
 // Forward declaration of `AssetAccountsResponse` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccountsResponse; }
-// Forward declaration of `AssetAccountQuery` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct AssetAccountQuery; }
+// Forward declaration of `AssetAccountsQuery` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct AssetAccountsQuery; }
 // Forward declaration of `AssetAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccount; }
 // Forward declaration of `AssetAccountRef` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccountRef; }
 // Forward declaration of `TradesResponse` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradesResponse; }
-// Forward declaration of `TradeQuery` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct TradeQuery; }
+// Forward declaration of `TradesQuery` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradesQuery; }
 // Forward declaration of `Trade` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct Trade; }
 // Forward declaration of `TradeRef` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeRef; }
 // Forward declaration of `TradeQuotesResponse` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuotesResponse; }
-// Forward declaration of `TradeQuoteRequest` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct TradeQuoteRequest; }
-// Forward declaration of `AnyMap` to properly resolve imports.
-namespace NitroModules { class AnyMap; }
-// Forward declaration of `ToolCall` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct ToolCall; }
+// Forward declaration of `TradeQuotesRequest` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeQuotesRequest; }
 
-#include <optional>
-#include <vector>
 #include "Service.hpp"
+#include <vector>
+#include <optional>
 #include <string>
 #include "PresentationBackground.hpp"
 #include "PresentationStyle.hpp"
-#include <functional>
 #include "LinkedAccount.hpp"
+#include <functional>
 #include "TradeQuote.hpp"
 #include "TradeExecutionResult.hpp"
-#include "AppUser.hpp"
 #include <NitroModules/Promise.hpp>
 #include "LinkedAccountRef.hpp"
 #include "AssetAccountsResponse.hpp"
-#include "AssetAccountQuery.hpp"
+#include "AssetAccountsQuery.hpp"
 #include "AssetAccount.hpp"
 #include "AssetAccountRef.hpp"
 #include "TradesResponse.hpp"
-#include "TradeQuery.hpp"
+#include "TradesQuery.hpp"
 #include "Trade.hpp"
 #include "TradeRef.hpp"
 #include "TradeQuotesResponse.hpp"
-#include "TradeQuoteRequest.hpp"
-#include <NitroModules/AnyMap.hpp>
-#include "ToolCall.hpp"
+#include "TradeQuotesRequest.hpp"
 
 namespace margelo::nitro::rncandle {
 
@@ -113,18 +104,17 @@ namespace margelo::nitro::rncandle {
       // Methods
       virtual 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) = 0;
       virtual void candleTradeExecutionSheet(const TradeQuote& tradeQuote, PresentationBackground presentationBackground, const std::function<void(const TradeExecutionResult& /* result */)>& completion) = 0;
-      virtual void initialize(const AppUser& appUser, const std::optional<std::string>& accessGroup) = 0;
+      virtual void initialize(const std::string& appKey, const std::string& appSecret, const std::optional<std::string>& accessGroup) = 0;
       virtual std::shared_ptr<Promise<std::vector<LinkedAccount>>> getLinkedAccounts() = 0;
       virtual std::shared_ptr<Promise<LinkedAccount>> getLinkedAccount(const LinkedAccountRef& ref) = 0;
       virtual std::shared_ptr<Promise<void>> unlinkAccount(const LinkedAccountRef& ref) = 0;
-      virtual std::shared_ptr<Promise<AssetAccountsResponse>> getAssetAccounts(const AssetAccountQuery& query) = 0;
+      virtual std::shared_ptr<Promise<AssetAccountsResponse>> getAssetAccounts(const AssetAccountsQuery& query) = 0;
       virtual std::shared_ptr<Promise<AssetAccount>> getAssetAccount(const AssetAccountRef& ref) = 0;
-      virtual std::shared_ptr<Promise<TradesResponse>> getTrades(const TradeQuery& query) = 0;
+      virtual std::shared_ptr<Promise<TradesResponse>> getTrades(const TradesQuery& query) = 0;
       virtual std::shared_ptr<Promise<Trade>> getTrade(const TradeRef& ref) = 0;
-      virtual std::shared_ptr<Promise<TradeQuotesResponse>> getTradeQuotes(const TradeQuoteRequest& request) = 0;
+      virtual std::shared_ptr<Promise<TradeQuotesResponse>> getTradeQuotes(const TradeQuotesRequest& request) = 0;
+      virtual std::shared_ptr<Promise<void>> createUser(const std::string& appUserID) = 0;
       virtual std::shared_ptr<Promise<void>> deleteUser() = 0;
-      virtual std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>> getAvailableTools() = 0;
-      virtual std::shared_ptr<Promise<std::string>> executeTool(const ToolCall& tool) = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/InactiveLinkedAccountDetails.hpp

@@ -40,18 +40,16 @@ namespace margelo::nitro::rncandle {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::rncandle;
-
   // C++ InactiveLinkedAccountDetails <> JS InactiveLinkedAccountDetails (object)
   template <>
-  struct JSIConverter<InactiveLinkedAccountDetails> final {
-    static inline InactiveLinkedAccountDetails fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::rncandle::InactiveLinkedAccountDetails> final {
+    static inline margelo::nitro::rncandle::InactiveLinkedAccountDetails fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return InactiveLinkedAccountDetails(
+      return margelo::nitro::rncandle::InactiveLinkedAccountDetails(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "state"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const InactiveLinkedAccountDetails& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rncandle::InactiveLinkedAccountDetails& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "state", JSIConverter<std::string>::toJSI(runtime, arg.state));
       return obj;

package/nitrogen/generated/shared/c++/LinkedAccount.hpp

@@ -48,26 +48,24 @@ namespace margelo::nitro::rncandle {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::rncandle;
-
   // C++ LinkedAccount <> JS LinkedAccount (object)
   template <>
-  struct JSIConverter<LinkedAccount> final {
-    static inline LinkedAccount fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::rncandle::LinkedAccount> final {
+    static inline margelo::nitro::rncandle::LinkedAccount fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return LinkedAccount(
+      return margelo::nitro::rncandle::LinkedAccount(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "linkedAccountID")),
-        JSIConverter<Service>::fromJSI(runtime, obj.getProperty(runtime, "service")),
+        JSIConverter<margelo::nitro::rncandle::Service>::fromJSI(runtime, obj.getProperty(runtime, "service")),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "serviceUserID")),
-        JSIConverter<LinkedAccountDetails>::fromJSI(runtime, obj.getProperty(runtime, "details"))
+        JSIConverter<margelo::nitro::rncandle::LinkedAccountDetails>::fromJSI(runtime, obj.getProperty(runtime, "details"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const LinkedAccount& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rncandle::LinkedAccount& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "linkedAccountID", JSIConverter<std::string>::toJSI(runtime, arg.linkedAccountID));
-      obj.setProperty(runtime, "service", JSIConverter<Service>::toJSI(runtime, arg.service));
+      obj.setProperty(runtime, "service", JSIConverter<margelo::nitro::rncandle::Service>::toJSI(runtime, arg.service));
       obj.setProperty(runtime, "serviceUserID", JSIConverter<std::string>::toJSI(runtime, arg.serviceUserID));
-      obj.setProperty(runtime, "details", JSIConverter<LinkedAccountDetails>::toJSI(runtime, arg.details));
+      obj.setProperty(runtime, "details", JSIConverter<margelo::nitro::rncandle::LinkedAccountDetails>::toJSI(runtime, arg.details));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -76,9 +74,9 @@ namespace margelo::nitro {
       }
       jsi::Object obj = value.getObject(runtime);
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "linkedAccountID"))) return false;
-      if (!JSIConverter<Service>::canConvert(runtime, obj.getProperty(runtime, "service"))) return false;
+      if (!JSIConverter<margelo::nitro::rncandle::Service>::canConvert(runtime, obj.getProperty(runtime, "service"))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "serviceUserID"))) return false;
-      if (!JSIConverter<LinkedAccountDetails>::canConvert(runtime, obj.getProperty(runtime, "details"))) return false;
+      if (!JSIConverter<margelo::nitro::rncandle::LinkedAccountDetails>::canConvert(runtime, obj.getProperty(runtime, "details"))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/LinkedAccountDetails.hpp

@@ -25,8 +25,8 @@ namespace margelo::nitro::rncandle { struct InactiveLinkedAccountDetails; }
 // Forward declaration of `UnavailableLinkedAccountDetails` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct UnavailableLinkedAccountDetails; }
 
-#include <optional>
 #include "ActiveLinkedAccountDetails.hpp"
+#include <optional>
 #include "InactiveLinkedAccountDetails.hpp"
 #include "UnavailableLinkedAccountDetails.hpp"
 
@@ -50,24 +50,22 @@ namespace margelo::nitro::rncandle {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::rncandle;
-
   // C++ LinkedAccountDetails <> JS LinkedAccountDetails (object)
   template <>
-  struct JSIConverter<LinkedAccountDetails> final {
-    static inline LinkedAccountDetails fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::rncandle::LinkedAccountDetails> final {
+    static inline margelo::nitro::rncandle::LinkedAccountDetails fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return LinkedAccountDetails(
-        JSIConverter<std::optional<ActiveLinkedAccountDetails>>::fromJSI(runtime, obj.getProperty(runtime, "activeLinkedAccountDetails")),
-        JSIConverter<std::optional<InactiveLinkedAccountDetails>>::fromJSI(runtime, obj.getProperty(runtime, "inactiveLinkedAccountDetails")),
-        JSIConverter<std::optional<UnavailableLinkedAccountDetails>>::fromJSI(runtime, obj.getProperty(runtime, "unavailableLinkedAccountDetails"))
+      return margelo::nitro::rncandle::LinkedAccountDetails(
+        JSIConverter<std::optional<margelo::nitro::rncandle::ActiveLinkedAccountDetails>>::fromJSI(runtime, obj.getProperty(runtime, "activeLinkedAccountDetails")),
+        JSIConverter<std::optional<margelo::nitro::rncandle::InactiveLinkedAccountDetails>>::fromJSI(runtime, obj.getProperty(runtime, "inactiveLinkedAccountDetails")),
+        JSIConverter<std::optional<margelo::nitro::rncandle::UnavailableLinkedAccountDetails>>::fromJSI(runtime, obj.getProperty(runtime, "unavailableLinkedAccountDetails"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const LinkedAccountDetails& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rncandle::LinkedAccountDetails& arg) {
       jsi::Object obj(runtime);
-      obj.setProperty(runtime, "activeLinkedAccountDetails", JSIConverter<std::optional<ActiveLinkedAccountDetails>>::toJSI(runtime, arg.activeLinkedAccountDetails));
-      obj.setProperty(runtime, "inactiveLinkedAccountDetails", JSIConverter<std::optional<InactiveLinkedAccountDetails>>::toJSI(runtime, arg.inactiveLinkedAccountDetails));
-      obj.setProperty(runtime, "unavailableLinkedAccountDetails", JSIConverter<std::optional<UnavailableLinkedAccountDetails>>::toJSI(runtime, arg.unavailableLinkedAccountDetails));
+      obj.setProperty(runtime, "activeLinkedAccountDetails", JSIConverter<std::optional<margelo::nitro::rncandle::ActiveLinkedAccountDetails>>::toJSI(runtime, arg.activeLinkedAccountDetails));
+      obj.setProperty(runtime, "inactiveLinkedAccountDetails", JSIConverter<std::optional<margelo::nitro::rncandle::InactiveLinkedAccountDetails>>::toJSI(runtime, arg.inactiveLinkedAccountDetails));
+      obj.setProperty(runtime, "unavailableLinkedAccountDetails", JSIConverter<std::optional<margelo::nitro::rncandle::UnavailableLinkedAccountDetails>>::toJSI(runtime, arg.unavailableLinkedAccountDetails));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -75,9 +73,9 @@ namespace margelo::nitro {
         return false;
       }
       jsi::Object obj = value.getObject(runtime);
-      if (!JSIConverter<std::optional<ActiveLinkedAccountDetails>>::canConvert(runtime, obj.getProperty(runtime, "activeLinkedAccountDetails"))) return false;
-      if (!JSIConverter<std::optional<InactiveLinkedAccountDetails>>::canConvert(runtime, obj.getProperty(runtime, "inactiveLinkedAccountDetails"))) return false;
-      if (!JSIConverter<std::optional<UnavailableLinkedAccountDetails>>::canConvert(runtime, obj.getProperty(runtime, "unavailableLinkedAccountDetails"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::rncandle::ActiveLinkedAccountDetails>>::canConvert(runtime, obj.getProperty(runtime, "activeLinkedAccountDetails"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::rncandle::InactiveLinkedAccountDetails>>::canConvert(runtime, obj.getProperty(runtime, "inactiveLinkedAccountDetails"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::rncandle::UnavailableLinkedAccountDetails>>::canConvert(runtime, obj.getProperty(runtime, "unavailableLinkedAccountDetails"))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/LinkedAccountRef.hpp

@@ -40,18 +40,16 @@ namespace margelo::nitro::rncandle {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::rncandle;
-
   // C++ LinkedAccountRef <> JS LinkedAccountRef (object)
   template <>
-  struct JSIConverter<LinkedAccountRef> final {
-    static inline LinkedAccountRef fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::rncandle::LinkedAccountRef> final {
+    static inline margelo::nitro::rncandle::LinkedAccountRef fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return LinkedAccountRef(
+      return margelo::nitro::rncandle::LinkedAccountRef(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "linkedAccountID"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const LinkedAccountRef& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rncandle::LinkedAccountRef& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "linkedAccountID", JSIConverter<std::string>::toJSI(runtime, arg.linkedAccountID));
       return obj;

package/nitrogen/generated/shared/c++/{StatePayload.hpp → LinkedAccountState.hpp}

@@ -1,5 +1,5 @@
 ///
-/// StatePayload.hpp
+/// LinkedAccountState.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -26,9 +26,9 @@
 namespace margelo::nitro::rncandle {
 
   /**
-   * An enum which can be represented as a JavaScript union (StatePayload).
+   * An enum which can be represented as a JavaScript union (LinkedAccountState).
    */
-  enum class StatePayload {
+  enum class LinkedAccountState {
     ACTIVE      SWIFT_NAME(active) = 0,
     INACTIVE      SWIFT_NAME(inactive) = 1,
     UNAVAILABLE      SWIFT_NAME(unavailable) = 2,
@@ -38,28 +38,26 @@ namespace margelo::nitro::rncandle {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::rncandle;
-
-  // C++ StatePayload <> JS StatePayload (union)
+  // C++ LinkedAccountState <> JS LinkedAccountState (union)
   template <>
-  struct JSIConverter<StatePayload> final {
-    static inline StatePayload fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::rncandle::LinkedAccountState> final {
+    static inline margelo::nitro::rncandle::LinkedAccountState fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("active"): return StatePayload::ACTIVE;
-        case hashString("inactive"): return StatePayload::INACTIVE;
-        case hashString("unavailable"): return StatePayload::UNAVAILABLE;
+        case hashString("active"): return margelo::nitro::rncandle::LinkedAccountState::ACTIVE;
+        case hashString("inactive"): return margelo::nitro::rncandle::LinkedAccountState::INACTIVE;
+        case hashString("unavailable"): return margelo::nitro::rncandle::LinkedAccountState::UNAVAILABLE;
         default: [[unlikely]]
-          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum StatePayload - invalid value!");
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum LinkedAccountState - invalid value!");
       }
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, StatePayload arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::rncandle::LinkedAccountState arg) {
       switch (arg) {
-        case StatePayload::ACTIVE: return JSIConverter<std::string>::toJSI(runtime, "active");
-        case StatePayload::INACTIVE: return JSIConverter<std::string>::toJSI(runtime, "inactive");
-        case StatePayload::UNAVAILABLE: return JSIConverter<std::string>::toJSI(runtime, "unavailable");
+        case margelo::nitro::rncandle::LinkedAccountState::ACTIVE: return JSIConverter<std::string>::toJSI(runtime, "active");
+        case margelo::nitro::rncandle::LinkedAccountState::INACTIVE: return JSIConverter<std::string>::toJSI(runtime, "inactive");
+        case margelo::nitro::rncandle::LinkedAccountState::UNAVAILABLE: return JSIConverter<std::string>::toJSI(runtime, "unavailable");
         default: [[unlikely]]
-          throw std::invalid_argument("Cannot convert StatePayload to JS - invalid value: "
+          throw std::invalid_argument("Cannot convert LinkedAccountState to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
       }
     }

package/nitrogen/generated/shared/c++/LinkedAccountStatusRef.hpp

@@ -20,12 +20,12 @@
 
 // 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 `LinkedAccountState` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class LinkedAccountState; }
 
 #include <string>
 #include "Service.hpp"
-#include "StatePayload.hpp"
+#include "LinkedAccountState.hpp"
 
 namespace margelo::nitro::rncandle {
 
@@ -37,37 +37,35 @@ namespace margelo::nitro::rncandle {
     std::string linkedAccountID     SWIFT_PRIVATE;
     Service service     SWIFT_PRIVATE;
     std::string serviceUserID     SWIFT_PRIVATE;
-    StatePayload state     SWIFT_PRIVATE;
+    LinkedAccountState state     SWIFT_PRIVATE;
 
   public:
     LinkedAccountStatusRef() = default;
-    explicit LinkedAccountStatusRef(std::string linkedAccountID, Service service, std::string serviceUserID, StatePayload state): linkedAccountID(linkedAccountID), service(service), serviceUserID(serviceUserID), state(state) {}
+    explicit LinkedAccountStatusRef(std::string linkedAccountID, Service service, std::string serviceUserID, LinkedAccountState state): linkedAccountID(linkedAccountID), service(service), serviceUserID(serviceUserID), state(state) {}
   };
 
 } // namespace margelo::nitro::rncandle
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::rncandle;
-
   // C++ LinkedAccountStatusRef <> JS LinkedAccountStatusRef (object)
   template <>
-  struct JSIConverter<LinkedAccountStatusRef> final {
-    static inline LinkedAccountStatusRef fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::rncandle::LinkedAccountStatusRef> final {
+    static inline margelo::nitro::rncandle::LinkedAccountStatusRef fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return LinkedAccountStatusRef(
+      return margelo::nitro::rncandle::LinkedAccountStatusRef(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "linkedAccountID")),
-        JSIConverter<Service>::fromJSI(runtime, obj.getProperty(runtime, "service")),
+        JSIConverter<margelo::nitro::rncandle::Service>::fromJSI(runtime, obj.getProperty(runtime, "service")),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "serviceUserID")),
-        JSIConverter<StatePayload>::fromJSI(runtime, obj.getProperty(runtime, "state"))
+        JSIConverter<margelo::nitro::rncandle::LinkedAccountState>::fromJSI(runtime, obj.getProperty(runtime, "state"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const LinkedAccountStatusRef& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rncandle::LinkedAccountStatusRef& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "linkedAccountID", JSIConverter<std::string>::toJSI(runtime, arg.linkedAccountID));
-      obj.setProperty(runtime, "service", JSIConverter<Service>::toJSI(runtime, arg.service));
+      obj.setProperty(runtime, "service", JSIConverter<margelo::nitro::rncandle::Service>::toJSI(runtime, arg.service));
       obj.setProperty(runtime, "serviceUserID", JSIConverter<std::string>::toJSI(runtime, arg.serviceUserID));
-      obj.setProperty(runtime, "state", JSIConverter<StatePayload>::toJSI(runtime, arg.state));
+      obj.setProperty(runtime, "state", JSIConverter<margelo::nitro::rncandle::LinkedAccountState>::toJSI(runtime, arg.state));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -76,9 +74,9 @@ namespace margelo::nitro {
       }
       jsi::Object obj = value.getObject(runtime);
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "linkedAccountID"))) return false;
-      if (!JSIConverter<Service>::canConvert(runtime, obj.getProperty(runtime, "service"))) return false;
+      if (!JSIConverter<margelo::nitro::rncandle::Service>::canConvert(runtime, obj.getProperty(runtime, "service"))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "serviceUserID"))) return false;
-      if (!JSIConverter<StatePayload>::canConvert(runtime, obj.getProperty(runtime, "state"))) return false;
+      if (!JSIConverter<margelo::nitro::rncandle::LinkedAccountState>::canConvert(runtime, obj.getProperty(runtime, "state"))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/MarketAccount.hpp

@@ -18,11 +18,14 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `MarketAssetKind` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class MarketAssetKind; }
 // Forward declaration of `FiatMarketAccountKind` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class FiatMarketAccountKind; }
 // Forward declaration of `Service` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class Service; }
 
+#include "MarketAssetKind.hpp"
 #include <string>
 #include "FiatMarketAccountKind.hpp"
 #include "Service.hpp"
@@ -34,7 +37,7 @@ namespace margelo::nitro::rncandle {
    */
   struct MarketAccount {
   public:
-    std::string assetKind     SWIFT_PRIVATE;
+    MarketAssetKind assetKind     SWIFT_PRIVATE;
     std::string serviceAccountID     SWIFT_PRIVATE;
     FiatMarketAccountKind accountKind     SWIFT_PRIVATE;
     std::string nickname     SWIFT_PRIVATE;
@@ -43,37 +46,35 @@ namespace margelo::nitro::rncandle {
 
   public:
     MarketAccount() = default;
-    explicit MarketAccount(std::string assetKind, std::string serviceAccountID, FiatMarketAccountKind accountKind, std::string nickname, std::string linkedAccountID, Service service): assetKind(assetKind), serviceAccountID(serviceAccountID), accountKind(accountKind), nickname(nickname), linkedAccountID(linkedAccountID), service(service) {}
+    explicit MarketAccount(MarketAssetKind assetKind, std::string serviceAccountID, FiatMarketAccountKind accountKind, std::string nickname, std::string linkedAccountID, Service service): assetKind(assetKind), serviceAccountID(serviceAccountID), accountKind(accountKind), nickname(nickname), linkedAccountID(linkedAccountID), service(service) {}
   };
 
 } // namespace margelo::nitro::rncandle
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::rncandle;
-
   // C++ MarketAccount <> JS MarketAccount (object)
   template <>
-  struct JSIConverter<MarketAccount> final {
-    static inline MarketAccount fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::rncandle::MarketAccount> final {
+    static inline margelo::nitro::rncandle::MarketAccount fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return MarketAccount(
-        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "assetKind")),
+      return margelo::nitro::rncandle::MarketAccount(
+        JSIConverter<margelo::nitro::rncandle::MarketAssetKind>::fromJSI(runtime, obj.getProperty(runtime, "assetKind")),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "serviceAccountID")),
-        JSIConverter<FiatMarketAccountKind>::fromJSI(runtime, obj.getProperty(runtime, "accountKind")),
+        JSIConverter<margelo::nitro::rncandle::FiatMarketAccountKind>::fromJSI(runtime, obj.getProperty(runtime, "accountKind")),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "nickname")),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "linkedAccountID")),
-        JSIConverter<Service>::fromJSI(runtime, obj.getProperty(runtime, "service"))
+        JSIConverter<margelo::nitro::rncandle::Service>::fromJSI(runtime, obj.getProperty(runtime, "service"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const MarketAccount& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rncandle::MarketAccount& arg) {
       jsi::Object obj(runtime);
-      obj.setProperty(runtime, "assetKind", JSIConverter<std::string>::toJSI(runtime, arg.assetKind));
+      obj.setProperty(runtime, "assetKind", JSIConverter<margelo::nitro::rncandle::MarketAssetKind>::toJSI(runtime, arg.assetKind));
       obj.setProperty(runtime, "serviceAccountID", JSIConverter<std::string>::toJSI(runtime, arg.serviceAccountID));
-      obj.setProperty(runtime, "accountKind", JSIConverter<FiatMarketAccountKind>::toJSI(runtime, arg.accountKind));
+      obj.setProperty(runtime, "accountKind", JSIConverter<margelo::nitro::rncandle::FiatMarketAccountKind>::toJSI(runtime, arg.accountKind));
       obj.setProperty(runtime, "nickname", JSIConverter<std::string>::toJSI(runtime, arg.nickname));
       obj.setProperty(runtime, "linkedAccountID", JSIConverter<std::string>::toJSI(runtime, arg.linkedAccountID));
-      obj.setProperty(runtime, "service", JSIConverter<Service>::toJSI(runtime, arg.service));
+      obj.setProperty(runtime, "service", JSIConverter<margelo::nitro::rncandle::Service>::toJSI(runtime, arg.service));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -81,12 +82,12 @@ namespace margelo::nitro {
         return false;
       }
       jsi::Object obj = value.getObject(runtime);
-      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "assetKind"))) return false;
+      if (!JSIConverter<margelo::nitro::rncandle::MarketAssetKind>::canConvert(runtime, obj.getProperty(runtime, "assetKind"))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "serviceAccountID"))) return false;
-      if (!JSIConverter<FiatMarketAccountKind>::canConvert(runtime, obj.getProperty(runtime, "accountKind"))) return false;
+      if (!JSIConverter<margelo::nitro::rncandle::FiatMarketAccountKind>::canConvert(runtime, obj.getProperty(runtime, "accountKind"))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "nickname"))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "linkedAccountID"))) return false;
-      if (!JSIConverter<Service>::canConvert(runtime, obj.getProperty(runtime, "service"))) return false;
+      if (!JSIConverter<margelo::nitro::rncandle::Service>::canConvert(runtime, obj.getProperty(runtime, "service"))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/MarketAssetKind.hpp

@@ -0,0 +1,76 @@
+///
+/// MarketAssetKind.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::rncandle {
+
+  /**
+   * An enum which can be represented as a JavaScript union (MarketAssetKind).
+   */
+  enum class MarketAssetKind {
+    STOCK      SWIFT_NAME(stock) = 0,
+    CRYPTO      SWIFT_NAME(crypto) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::rncandle
+
+namespace margelo::nitro {
+
+  // C++ MarketAssetKind <> JS MarketAssetKind (union)
+  template <>
+  struct JSIConverter<margelo::nitro::rncandle::MarketAssetKind> final {
+    static inline margelo::nitro::rncandle::MarketAssetKind fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("stock"): return margelo::nitro::rncandle::MarketAssetKind::STOCK;
+        case hashString("crypto"): return margelo::nitro::rncandle::MarketAssetKind::CRYPTO;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum MarketAssetKind - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::rncandle::MarketAssetKind arg) {
+      switch (arg) {
+        case margelo::nitro::rncandle::MarketAssetKind::STOCK: return JSIConverter<std::string>::toJSI(runtime, "stock");
+        case margelo::nitro::rncandle::MarketAssetKind::CRYPTO: return JSIConverter<std::string>::toJSI(runtime, "crypto");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert MarketAssetKind to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("stock"):
+        case hashString("crypto"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro