@onekeyfe/react-native-device-utils 1.1.19 → 1.1.21

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

@@ -10,8 +10,14 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `DualScreenInfoRect` to properly resolve imports.
 namespace margelo::nitro::reactnativedeviceutils { struct DualScreenInfoRect; }
+// Forward declaration of `GooglePlayServicesStatus` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct GooglePlayServicesStatus; }
 // Forward declaration of `HybridReactNativeDeviceUtilsSpec` to properly resolve imports.
 namespace margelo::nitro::reactnativedeviceutils { class HybridReactNativeDeviceUtilsSpec; }
+// Forward declaration of `LaunchOptions` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct LaunchOptions; }
+// Forward declaration of `WebViewPackageInfo` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct WebViewPackageInfo; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridReactNativeDeviceUtilsSpec_cxx` to properly resolve imports.
@@ -19,13 +25,18 @@ namespace ReactNativeDeviceUtils { class HybridReactNativeDeviceUtilsSpec_cxx; }
 
 // Include C++ defined types
 #include "DualScreenInfoRect.hpp"
+#include "GooglePlayServicesStatus.hpp"
 #include "HybridReactNativeDeviceUtilsSpec.hpp"
+#include "LaunchOptions.hpp"
+#include "WebViewPackageInfo.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
 #include <memory>
+#include <optional>
+#include <string>
 #include <vector>
 
 /**
@@ -157,6 +168,237 @@ namespace margelo::nitro::reactnativedeviceutils::bridge::swift {
     return Func_void_bool_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<LaunchOptions>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<LaunchOptions>>`.
+   */
+  using std__shared_ptr_Promise_LaunchOptions__ = std::shared_ptr<Promise<LaunchOptions>>;
+  inline std::shared_ptr<Promise<LaunchOptions>> create_std__shared_ptr_Promise_LaunchOptions__() noexcept {
+    return Promise<LaunchOptions>::create();
+  }
+  inline PromiseHolder<LaunchOptions> wrap_std__shared_ptr_Promise_LaunchOptions__(std::shared_ptr<Promise<LaunchOptions>> promise) noexcept {
+    return PromiseHolder<LaunchOptions>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const LaunchOptions& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const LaunchOptions&)>`.
+   */
+  using Func_void_LaunchOptions = std::function<void(const LaunchOptions& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const LaunchOptions& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_LaunchOptions_Wrapper final {
+  public:
+    explicit Func_void_LaunchOptions_Wrapper(std::function<void(const LaunchOptions& /* result */)>&& func): _function(std::make_unique<std::function<void(const LaunchOptions& /* result */)>>(std::move(func))) {}
+    inline void call(LaunchOptions result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const LaunchOptions& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_LaunchOptions create_Func_void_LaunchOptions(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_LaunchOptions_Wrapper wrap_Func_void_LaunchOptions(Func_void_LaunchOptions value) noexcept {
+    return Func_void_LaunchOptions_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
+  // 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__() noexcept {
+    return Promise<std::string>::create();
+  }
+  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) noexcept {
+    return PromiseHolder<std::string>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_Wrapper final {
+  public:
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
+    inline void call(std::string result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
+    return Func_void_std__string_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<void>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   */
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
+    return Promise<void>::create();
+  }
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
+    }
+  private:
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<double>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<double>>`.
+   */
+  using std__shared_ptr_Promise_double__ = std::shared_ptr<Promise<double>>;
+  inline std::shared_ptr<Promise<double>> create_std__shared_ptr_Promise_double__() noexcept {
+    return Promise<double>::create();
+  }
+  inline PromiseHolder<double> wrap_std__shared_ptr_Promise_double__(std::shared_ptr<Promise<double>> promise) noexcept {
+    return PromiseHolder<double>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(double /* result */)>
+  /**
+   * Specialized version of `std::function<void(double)>`.
+   */
+  using Func_void_double = std::function<void(double /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_Wrapper final {
+  public:
+    explicit Func_void_double_Wrapper(std::function<void(double /* result */)>&& func): _function(std::make_unique<std::function<void(double /* result */)>>(std::move(func))) {}
+    inline void call(double result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) noexcept {
+    return Func_void_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<WebViewPackageInfo>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<WebViewPackageInfo>>`.
+   */
+  using std__shared_ptr_Promise_WebViewPackageInfo__ = std::shared_ptr<Promise<WebViewPackageInfo>>;
+  inline std::shared_ptr<Promise<WebViewPackageInfo>> create_std__shared_ptr_Promise_WebViewPackageInfo__() noexcept {
+    return Promise<WebViewPackageInfo>::create();
+  }
+  inline PromiseHolder<WebViewPackageInfo> wrap_std__shared_ptr_Promise_WebViewPackageInfo__(std::shared_ptr<Promise<WebViewPackageInfo>> promise) noexcept {
+    return PromiseHolder<WebViewPackageInfo>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const WebViewPackageInfo& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const WebViewPackageInfo&)>`.
+   */
+  using Func_void_WebViewPackageInfo = std::function<void(const WebViewPackageInfo& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const WebViewPackageInfo& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_WebViewPackageInfo_Wrapper final {
+  public:
+    explicit Func_void_WebViewPackageInfo_Wrapper(std::function<void(const WebViewPackageInfo& /* result */)>&& func): _function(std::make_unique<std::function<void(const WebViewPackageInfo& /* result */)>>(std::move(func))) {}
+    inline void call(WebViewPackageInfo result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const WebViewPackageInfo& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_WebViewPackageInfo create_Func_void_WebViewPackageInfo(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_WebViewPackageInfo_Wrapper wrap_Func_void_WebViewPackageInfo(Func_void_WebViewPackageInfo value) noexcept {
+    return Func_void_WebViewPackageInfo_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<GooglePlayServicesStatus>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<GooglePlayServicesStatus>>`.
+   */
+  using std__shared_ptr_Promise_GooglePlayServicesStatus__ = std::shared_ptr<Promise<GooglePlayServicesStatus>>;
+  inline std::shared_ptr<Promise<GooglePlayServicesStatus>> create_std__shared_ptr_Promise_GooglePlayServicesStatus__() noexcept {
+    return Promise<GooglePlayServicesStatus>::create();
+  }
+  inline PromiseHolder<GooglePlayServicesStatus> wrap_std__shared_ptr_Promise_GooglePlayServicesStatus__(std::shared_ptr<Promise<GooglePlayServicesStatus>> promise) noexcept {
+    return PromiseHolder<GooglePlayServicesStatus>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const GooglePlayServicesStatus& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const GooglePlayServicesStatus&)>`.
+   */
+  using Func_void_GooglePlayServicesStatus = std::function<void(const GooglePlayServicesStatus& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const GooglePlayServicesStatus& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_GooglePlayServicesStatus_Wrapper final {
+  public:
+    explicit Func_void_GooglePlayServicesStatus_Wrapper(std::function<void(const GooglePlayServicesStatus& /* result */)>&& func): _function(std::make_unique<std::function<void(const GooglePlayServicesStatus& /* result */)>>(std::move(func))) {}
+    inline void call(GooglePlayServicesStatus result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const GooglePlayServicesStatus& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_GooglePlayServicesStatus create_Func_void_GooglePlayServicesStatus(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_GooglePlayServicesStatus_Wrapper wrap_Func_void_GooglePlayServicesStatus(Func_void_GooglePlayServicesStatus value) noexcept {
+    return Func_void_GooglePlayServicesStatus_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridReactNativeDeviceUtilsSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridReactNativeDeviceUtilsSpec>`.
@@ -213,5 +455,68 @@ namespace margelo::nitro::reactnativedeviceutils::bridge::swift {
   inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
     return Result<double>::withError(error);
   }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<LaunchOptions>>>
+  using Result_std__shared_ptr_Promise_LaunchOptions___ = Result<std::shared_ptr<Promise<LaunchOptions>>>;
+  inline Result_std__shared_ptr_Promise_LaunchOptions___ create_Result_std__shared_ptr_Promise_LaunchOptions___(const std::shared_ptr<Promise<LaunchOptions>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<LaunchOptions>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_LaunchOptions___ create_Result_std__shared_ptr_Promise_LaunchOptions___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<LaunchOptions>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
+  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::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) noexcept {
+    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) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<void>>>
+  using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<double>>>
+  using Result_std__shared_ptr_Promise_double___ = Result<std::shared_ptr<Promise<double>>>;
+  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::shared_ptr<Promise<double>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<double>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<double>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<WebViewPackageInfo>>>
+  using Result_std__shared_ptr_Promise_WebViewPackageInfo___ = Result<std::shared_ptr<Promise<WebViewPackageInfo>>>;
+  inline Result_std__shared_ptr_Promise_WebViewPackageInfo___ create_Result_std__shared_ptr_Promise_WebViewPackageInfo___(const std::shared_ptr<Promise<WebViewPackageInfo>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<WebViewPackageInfo>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_WebViewPackageInfo___ create_Result_std__shared_ptr_Promise_WebViewPackageInfo___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<WebViewPackageInfo>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<GooglePlayServicesStatus>>>
+  using Result_std__shared_ptr_Promise_GooglePlayServicesStatus___ = Result<std::shared_ptr<Promise<GooglePlayServicesStatus>>>;
+  inline Result_std__shared_ptr_Promise_GooglePlayServicesStatus___ create_Result_std__shared_ptr_Promise_GooglePlayServicesStatus___(const std::shared_ptr<Promise<GooglePlayServicesStatus>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<GooglePlayServicesStatus>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_GooglePlayServicesStatus___ create_Result_std__shared_ptr_Promise_GooglePlayServicesStatus___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<GooglePlayServicesStatus>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::reactnativedeviceutils::bridge::swift

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

@@ -10,20 +10,31 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `DualScreenInfoRect` to properly resolve imports.
 namespace margelo::nitro::reactnativedeviceutils { struct DualScreenInfoRect; }
+// Forward declaration of `GooglePlayServicesStatus` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct GooglePlayServicesStatus; }
 // Forward declaration of `HybridReactNativeDeviceUtilsSpec` to properly resolve imports.
 namespace margelo::nitro::reactnativedeviceutils { class HybridReactNativeDeviceUtilsSpec; }
+// Forward declaration of `LaunchOptions` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct LaunchOptions; }
 // Forward declaration of `UserInterfaceStyle` to properly resolve imports.
 namespace margelo::nitro::reactnativedeviceutils { enum class UserInterfaceStyle; }
+// Forward declaration of `WebViewPackageInfo` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct WebViewPackageInfo; }
 
 // Include C++ defined types
 #include "DualScreenInfoRect.hpp"
+#include "GooglePlayServicesStatus.hpp"
 #include "HybridReactNativeDeviceUtilsSpec.hpp"
+#include "LaunchOptions.hpp"
 #include "UserInterfaceStyle.hpp"
+#include "WebViewPackageInfo.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
 #include <memory>
+#include <optional>
+#include <string>
 #include <vector>
 
 // C++ helpers for Swift

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

@@ -16,12 +16,23 @@ namespace ReactNativeDeviceUtils { class HybridReactNativeDeviceUtilsSpec_cxx; }
 namespace margelo::nitro::reactnativedeviceutils { struct DualScreenInfoRect; }
 // Forward declaration of `UserInterfaceStyle` to properly resolve imports.
 namespace margelo::nitro::reactnativedeviceutils { enum class UserInterfaceStyle; }
+// Forward declaration of `LaunchOptions` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct LaunchOptions; }
+// Forward declaration of `WebViewPackageInfo` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct WebViewPackageInfo; }
+// Forward declaration of `GooglePlayServicesStatus` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct GooglePlayServicesStatus; }
 
 #include "DualScreenInfoRect.hpp"
 #include <vector>
 #include <NitroModules/Promise.hpp>
 #include <functional>
 #include "UserInterfaceStyle.hpp"
+#include "LaunchOptions.hpp"
+#include <string>
+#include <optional>
+#include "WebViewPackageInfo.hpp"
+#include "GooglePlayServicesStatus.hpp"
 
 #include "ReactNativeDeviceUtils-Swift-Cxx-Umbrella.hpp"
 
@@ -131,6 +142,76 @@ namespace margelo::nitro::reactnativedeviceutils {
         std::rethrow_exception(__result.error());
       }
     }
+    inline std::shared_ptr<Promise<LaunchOptions>> getLaunchOptions() override {
+      auto __result = _swiftPart.getLaunchOptions();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> clearLaunchOptions() override {
+      auto __result = _swiftPart.clearLaunchOptions();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> getDeviceToken() override {
+      auto __result = _swiftPart.getDeviceToken();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> saveDeviceToken(const std::string& token) override {
+      auto __result = _swiftPart.saveDeviceToken(token);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> registerDeviceToken() override {
+      auto __result = _swiftPart.registerDeviceToken();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<double>> getStartupTime() override {
+      auto __result = _swiftPart.getStartupTime();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void exitApp() override {
+      auto __result = _swiftPart.exitApp();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<WebViewPackageInfo>> getCurrentWebViewPackageInfo() override {
+      auto __result = _swiftPart.getCurrentWebViewPackageInfo();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<GooglePlayServicesStatus>> isGooglePlayServicesAvailable() override {
+      auto __result = _swiftPart.isGooglePlayServicesAvailable();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     ReactNativeDeviceUtils::HybridReactNativeDeviceUtilsSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/Func_void.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `() -> 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 {
+  public typealias bridge = margelo.nitro.reactnativedeviceutils.bridge.swift
+
+  private let closure: () -> Void
+
+  public init(_ closure: @escaping () -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call() -> Void {
+    self.closure()
+  }
+
+  /**
+   * 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`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void {
+    return Unmanaged<Func_void>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_GooglePlayServicesStatus.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_GooglePlayServicesStatus.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: GooglePlayServicesStatus) -> 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_GooglePlayServicesStatus {
+  public typealias bridge = margelo.nitro.reactnativedeviceutils.bridge.swift
+
+  private let closure: (_ value: GooglePlayServicesStatus) -> Void
+
+  public init(_ closure: @escaping (_ value: GooglePlayServicesStatus) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: GooglePlayServicesStatus) -> Void {
+    self.closure(value)
+  }
+
+  /**
+   * 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_GooglePlayServicesStatus`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_GooglePlayServicesStatus>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_GooglePlayServicesStatus {
+    return Unmanaged<Func_void_GooglePlayServicesStatus>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_LaunchOptions.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_LaunchOptions.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: LaunchOptions) -> 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_LaunchOptions {
+  public typealias bridge = margelo.nitro.reactnativedeviceutils.bridge.swift
+
+  private let closure: (_ value: LaunchOptions) -> Void
+
+  public init(_ closure: @escaping (_ value: LaunchOptions) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: LaunchOptions) -> Void {
+    self.closure(value)
+  }
+
+  /**
+   * 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_LaunchOptions`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_LaunchOptions>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_LaunchOptions {
+    return Unmanaged<Func_void_LaunchOptions>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_WebViewPackageInfo.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_WebViewPackageInfo.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: WebViewPackageInfo) -> 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_WebViewPackageInfo {
+  public typealias bridge = margelo.nitro.reactnativedeviceutils.bridge.swift
+
+  private let closure: (_ value: WebViewPackageInfo) -> Void
+
+  public init(_ closure: @escaping (_ value: WebViewPackageInfo) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: WebViewPackageInfo) -> Void {
+    self.closure(value)
+  }
+
+  /**
+   * 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_WebViewPackageInfo`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_WebViewPackageInfo>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_WebViewPackageInfo {
+    return Unmanaged<Func_void_WebViewPackageInfo>.fromOpaque(pointer).takeRetainedValue()
+  }
+}