react-native-candle 0.1.4 → 0.1.6

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

@@ -8,15 +8,27 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `Details` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Details; }
 // Forward declaration of `HybridRNCandleSpec` to properly resolve imports.
 namespace margelo::nitro::rncandle { class HybridRNCandleSpec; }
+// 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 { enum class Service; }
+// Forward declaration of `State` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class State; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridRNCandleSpec_cxx` to properly resolve imports.
 namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 
 // Include C++ defined types
+#include "Details.hpp"
 #include "HybridRNCandleSpec.hpp"
+#include "LinkedAccount.hpp"
+#include "Service.hpp"
+#include "State.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -25,6 +37,7 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
 #include <memory>
 #include <optional>
 #include <string>
+#include <vector>
 
 /**
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
@@ -32,6 +45,26 @@ namespace ReactNativeCandle { class HybridRNCandleSpec_cxx; }
  */
 namespace margelo::nitro::rncandle::bridge::swift {
 
+  // pragma MARK: std::vector<Service>
+  /**
+   * Specialized version of `std::vector<Service>`.
+   */
+  using std__vector_Service_ = std::vector<Service>;
+  inline std::vector<Service> create_std__vector_Service_(size_t size) {
+    std::vector<Service> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<Service>>
+  /**
+   * 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) {
+    return std::optional<std::vector<Service>>(value);
+  }
+  
   // pragma MARK: std::optional<std::string>
   /**
    * Specialized version of `std::optional<std::string>`.
@@ -63,16 +96,58 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Func_void_std__string_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::string>>
+  // pragma MARK: std::optional<Details>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
+   * Specialized version of `std::optional<Details>`.
    */
-  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
-  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() {
-    return Promise<std::string>::create();
+  using std__optional_Details_ = std::optional<Details>;
+  inline std::optional<Details> create_std__optional_Details_(const Details& value) {
+    return std::optional<Details>(value);
   }
-  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) {
-    return PromiseHolder<std::string>(std::move(promise));
+  
+  // pragma MARK: std::vector<LinkedAccount>
+  /**
+   * Specialized version of `std::vector<LinkedAccount>`.
+   */
+  using std__vector_LinkedAccount_ = std::vector<LinkedAccount>;
+  inline std::vector<LinkedAccount> create_std__vector_LinkedAccount_(size_t size) {
+    std::vector<LinkedAccount> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<LinkedAccount>>>
+  /**
+   * 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___() {
+    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) {
+    return PromiseHolder<std::vector<LinkedAccount>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<LinkedAccount>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<LinkedAccount>&)>`.
+   */
+  using Func_void_std__vector_LinkedAccount_ = std::function<void(const std::vector<LinkedAccount>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<LinkedAccount>& / * result * /)>`, this can be used from 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 {
+      _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) {
+    return Func_void_std__vector_LinkedAccount__Wrapper(std::move(value));
   }
   
   // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
@@ -131,6 +206,18 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Func_void_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::shared_ptr<Promise<std::string>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
+   */
+  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
+  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() {
+    return Promise<std::string>::create();
+  }
+  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) {
+    return PromiseHolder<std::string>(std::move(promise));
+  }
+  
   // pragma MARK: std::shared_ptr<margelo::nitro::rncandle::HybridRNCandleSpec>
   /**
    * Specialized version of `std::shared_ptr<margelo::nitro::rncandle::HybridRNCandleSpec>`.
@@ -152,13 +239,13 @@ namespace margelo::nitro::rncandle::bridge::swift {
     return Result<void>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
-  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) {
-    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<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) {
+    return Result<std::shared_ptr<Promise<std::vector<LinkedAccount>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__vector_LinkedAccount____ create_Result_std__shared_ptr_Promise_std__vector_LinkedAccount____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::vector<LinkedAccount>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<void>>>
@@ -169,5 +256,14 @@ namespace margelo::nitro::rncandle::bridge::swift {
   inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
+  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) {
+    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
+  }
+  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

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

@@ -8,22 +8,31 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `Details` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Details; }
 // Forward declaration of `HybridRNCandleSpec` to properly resolve imports.
 namespace margelo::nitro::rncandle { class HybridRNCandleSpec; }
+// Forward declaration of `LinkedAccount` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct LinkedAccount; }
 // 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 `Service` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class Service; }
+// Forward declaration of `State` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class State; }
 // Forward declaration of `ToolCall` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct ToolCall; }
 
 // Include C++ defined types
+#include "Details.hpp"
 #include "HybridRNCandleSpec.hpp"
+#include "LinkedAccount.hpp"
 #include "PresentationBackground.hpp"
 #include "PresentationStyle.hpp"
 #include "Service.hpp"
+#include "State.hpp"
 #include "ToolCall.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
@@ -32,6 +41,7 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include <memory>
 #include <optional>
 #include <string>
+#include <vector>
 
 // C++ helpers for Swift
 #include "ReactNativeCandle-Swift-Cxx-Bridge.hpp"

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

@@ -18,16 +18,26 @@ namespace margelo::nitro::rncandle { enum class Service; }
 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 `Details` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Details; }
+// Forward declaration of `State` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class State; }
 // Forward declaration of `ToolCall` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct ToolCall; }
 
-#include "Service.hpp"
 #include <optional>
+#include <vector>
+#include "Service.hpp"
 #include <string>
 #include "PresentationBackground.hpp"
 #include "PresentationStyle.hpp"
 #include <functional>
 #include <NitroModules/Promise.hpp>
+#include "LinkedAccount.hpp"
+#include "Details.hpp"
+#include "State.hpp"
 #include "ToolCall.hpp"
 
 #include "ReactNativeCandle-Swift-Cxx-Umbrella.hpp"
@@ -69,13 +79,13 @@ namespace margelo::nitro::rncandle {
 
   public:
     // Methods
-    inline void candleLinkSheet(bool isPresented, Service service, double cornerRadius, const std::optional<std::string>& customerName, bool showSandbox, bool showDynamicLoading, PresentationBackground presentationBackground, PresentationStyle presentationStyle, const std::function<void(const std::string& /* account */)>& onSuccess) override {
-      auto __result = _swiftPart.candleLinkSheet(std::forward<decltype(isPresented)>(isPresented), static_cast<int>(service), std::forward<decltype(cornerRadius)>(cornerRadius), customerName, std::forward<decltype(showSandbox)>(showSandbox), std::forward<decltype(showDynamicLoading)>(showDynamicLoading), static_cast<int>(presentationBackground), static_cast<int>(presentationStyle), onSuccess);
+    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 std::string& /* 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);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
-    inline std::shared_ptr<Promise<std::string>> getLinkedAccounts() override {
+    inline std::shared_ptr<Promise<std::vector<LinkedAccount>>> getLinkedAccounts() override {
       auto __result = _swiftPart.getLinkedAccounts();
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/Details.swift

@@ -0,0 +1,105 @@
+///
+/// Details.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// Represents an instance of `Details`, backed by a C++ struct.
+public typealias Details = margelo.nitro.rncandle.Details
+
+extension Details {
+  private typealias bridge = margelo.nitro.rncandle.bridge.swift
+
+  /**
+   * Create a new instance of `Details`.
+   */
+  public init(state: State, username: String?, legalName: String, accountOpened: String?) {
+    self.init(
+      state,
+      { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = username {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }(), std.string(legalName),
+      { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = accountOpened {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }())
+  }
+
+  public var state: State {
+    @inline(__always)
+    get {
+      return self.__state
+    }
+    @inline(__always)
+    set {
+      self.__state = newValue
+    }
+  }
+
+  public var username: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if let __unwrapped = self.__username.value {
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__username = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+
+  public var legalName: String {
+    @inline(__always)
+    get {
+      return String(self.__legalName)
+    }
+    @inline(__always)
+    set {
+      self.__legalName = std.string(newValue)
+    }
+  }
+
+  public var accountOpened: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if let __unwrapped = self.__accountOpened.value {
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__accountOpened = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__vector_LinkedAccount_.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_std__vector_LinkedAccount_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// Wraps a Swift `(_ value: [LinkedAccount]) -> Void` as a class.
+/// This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+public final class Func_void_std__vector_LinkedAccount_ {
+  public typealias bridge = margelo.nitro.rncandle.bridge.swift
+
+  private let closure: (_ value: [LinkedAccount]) -> Void
+
+  public init(_ closure: @escaping (_ value: [LinkedAccount]) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__vector_LinkedAccount_) {
+    self.closure(value.map({ __item in __item }))
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__vector_LinkedAccount_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__vector_LinkedAccount_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer)
+    -> Func_void_std__vector_LinkedAccount_
+  {
+    return Unmanaged<Func_void_std__vector_LinkedAccount_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridRNCandleSpec.swift

@@ -14,10 +14,10 @@ public protocol HybridRNCandleSpec_protocol: HybridObject {
 
   // Methods
   func candleLinkSheet(
-    isPresented: Bool, service: Service, cornerRadius: Double, customerName: String?,
-    showSandbox: Bool, showDynamicLoading: Bool, presentationBackground: PresentationBackground,
+    isPresented: Bool, services: [Service]?, cornerRadius: Double, customerName: String?,
+    showDynamicLoading: Bool, presentationBackground: PresentationBackground,
     presentationStyle: PresentationStyle, onSuccess: @escaping (_ account: String) -> Void) throws
-  func getLinkedAccounts() throws -> Promise<String>
+  func getLinkedAccounts() throws -> Promise<[LinkedAccount]>
   func unlinkAccount(linkedAccountID: String) throws -> Promise<Void>
   func getFiatAccounts() throws -> Promise<String>
   func getActivity(span: String?) throws -> Promise<String>

package/nitrogen/generated/ios/swift/HybridRNCandleSpec_cxx.swift

@@ -99,21 +99,27 @@ public class HybridRNCandleSpec_cxx {
   // Methods
   @inline(__always)
   public final func candleLinkSheet(
-    isPresented: Bool, service: Int32, cornerRadius: Double,
-    customerName: bridge.std__optional_std__string_, showSandbox: Bool, showDynamicLoading: Bool,
+    isPresented: Bool, services: bridge.std__optional_std__vector_Service__, cornerRadius: Double,
+    customerName: bridge.std__optional_std__string_, showDynamicLoading: Bool,
     presentationBackground: Int32, presentationStyle: Int32, onSuccess: bridge.Func_void_std__string
   ) -> bridge.Result_void_ {
     do {
       try self.__implementation.candleLinkSheet(
-        isPresented: isPresented, service: margelo.nitro.rncandle.Service(rawValue: service)!,
-        cornerRadius: cornerRadius,
+        isPresented: isPresented,
+        services: { () -> [Service]? in
+          if let __unwrapped = services.value {
+            return __unwrapped.map({ __item in __item })
+          } else {
+            return nil
+          }
+        }(), cornerRadius: cornerRadius,
         customerName: { () -> String? in
           if let __unwrapped = customerName.value {
             return String(__unwrapped)
           } else {
             return nil
           }
-        }(), showSandbox: showSandbox, showDynamicLoading: showDynamicLoading,
+        }(), showDynamicLoading: showDynamicLoading,
         presentationBackground: margelo.nitro.rncandle.PresentationBackground(
           rawValue: presentationBackground)!,
         presentationStyle: margelo.nitro.rncandle.PresentationStyle(rawValue: presentationStyle)!,
@@ -131,21 +137,34 @@ public class HybridRNCandleSpec_cxx {
   }
 
   @inline(__always)
-  public final func getLinkedAccounts() -> bridge.Result_std__shared_ptr_Promise_std__string___ {
+  public final func getLinkedAccounts()
+    -> bridge.Result_std__shared_ptr_Promise_std__vector_LinkedAccount____
+  {
     do {
       let __result = try self.__implementation.getLinkedAccounts()
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in
-        let __promise = bridge.create_std__shared_ptr_Promise_std__string__()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_LinkedAccount___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_LinkedAccount___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_LinkedAccount___(
+          __promise)
         __result
-          .then({ __result in __promiseHolder.resolve(std.string(__result)) })
+          .then({ __result in
+            __promiseHolder.resolve(
+              { () -> bridge.std__vector_LinkedAccount_ in
+                var __vector = bridge.create_std__vector_LinkedAccount_(__result.count)
+                for __item in __result {
+                  __vector.push_back(__item)
+                }
+                return __vector
+              }())
+          })
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_LinkedAccount____(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_LinkedAccount____(
+        __exceptionPtr)
     }
   }
 

package/nitrogen/generated/ios/swift/LinkedAccount.swift

@@ -0,0 +1,86 @@
+///
+/// LinkedAccount.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// Represents an instance of `LinkedAccount`, backed by a C++ struct.
+public typealias LinkedAccount = margelo.nitro.rncandle.LinkedAccount
+
+extension LinkedAccount {
+  private typealias bridge = margelo.nitro.rncandle.bridge.swift
+
+  /**
+   * Create a new instance of `LinkedAccount`.
+   */
+  public init(serviceUserID: String, details: Details?, linkedAccountID: String, service: Service) {
+    self.init(
+      std.string(serviceUserID),
+      { () -> bridge.std__optional_Details_ in
+        if let __unwrappedValue = details {
+          return bridge.create_std__optional_Details_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }(), std.string(linkedAccountID), service)
+  }
+
+  public var serviceUserID: String {
+    @inline(__always)
+    get {
+      return String(self.__serviceUserID)
+    }
+    @inline(__always)
+    set {
+      self.__serviceUserID = std.string(newValue)
+    }
+  }
+
+  public var details: Details? {
+    @inline(__always)
+    get {
+      return { () -> Details? in
+        if let __unwrapped = self.__details.value {
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__details = { () -> bridge.std__optional_Details_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_Details_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+
+  public var linkedAccountID: String {
+    @inline(__always)
+    get {
+      return String(self.__linkedAccountID)
+    }
+    @inline(__always)
+    set {
+      self.__linkedAccountID = std.string(newValue)
+    }
+  }
+
+  public var service: Service {
+    @inline(__always)
+    get {
+      return self.__service
+    }
+    @inline(__always)
+    set {
+      self.__service = newValue
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Service.swift

@@ -23,14 +23,12 @@ extension Service {
       self = .venmo
     case "apple":
       self = .apple
-    case "demo":
-      self = .demo
+    case "sandbox":
+      self = .sandbox
     case "uber":
       self = .uber
     case "lyft":
       self = .lyft
-    case "default":
-      self = .default
     default:
       return nil
     }
@@ -49,14 +47,12 @@ extension Service {
       return "venmo"
     case .apple:
       return "apple"
-    case .demo:
-      return "demo"
+    case .sandbox:
+      return "sandbox"
     case .uber:
       return "uber"
     case .lyft:
       return "lyft"
-    case .default:
-      return "default"
     }
   }
 }

package/nitrogen/generated/ios/swift/State.swift

@@ -0,0 +1,38 @@
+///
+/// State.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+/// Represents the JS union `State`, backed by a C++ enum.
+public typealias State = margelo.nitro.rncandle.State
+
+extension State {
+  /**
+   * Get a State for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  public init?(fromString string: String) {
+    switch string {
+    case "active":
+      self = .active
+    case "inactive":
+      self = .inactive
+    default:
+      return nil
+    }
+  }
+
+  /**
+   * Get the String value this State represents.
+   */
+  public var stringValue: String {
+    switch self {
+    case .active:
+      return "active"
+    case .inactive:
+      return "inactive"
+    }
+  }
+}