@onekeyfe/react-native-device-utils 1.1.20 → 1.1.22

package/nitrogen/generated/android/c++/JWebViewPackageInfo.hpp

@@ -0,0 +1,65 @@
+///
+/// JWebViewPackageInfo.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "WebViewPackageInfo.hpp"
+
+#include <string>
+
+namespace margelo::nitro::reactnativedeviceutils {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "WebViewPackageInfo" and the the Kotlin data class "WebViewPackageInfo".
+   */
+  struct JWebViewPackageInfo final: public jni::JavaClass<JWebViewPackageInfo> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/WebViewPackageInfo;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct WebViewPackageInfo by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    WebViewPackageInfo toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPackageName = clazz->getField<jni::JString>("packageName");
+      jni::local_ref<jni::JString> packageName = this->getFieldValue(fieldPackageName);
+      static const auto fieldVersionName = clazz->getField<jni::JString>("versionName");
+      jni::local_ref<jni::JString> versionName = this->getFieldValue(fieldVersionName);
+      static const auto fieldVersionCode = clazz->getField<double>("versionCode");
+      double versionCode = this->getFieldValue(fieldVersionCode);
+      return WebViewPackageInfo(
+        packageName->toStdString(),
+        versionName->toStdString(),
+        versionCode
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JWebViewPackageInfo::javaobject> fromCpp(const WebViewPackageInfo& value) {
+      using JSignature = JWebViewPackageInfo(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.packageName),
+        jni::make_jstring(value.versionName),
+        value.versionCode
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativedeviceutils

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativedeviceutils/GooglePlayServicesStatus.kt

@@ -0,0 +1,41 @@
+///
+/// GooglePlayServicesStatus.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativedeviceutils
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "GooglePlayServicesStatus".
+ */
+@DoNotStrip
+@Keep
+data class GooglePlayServicesStatus(
+  @DoNotStrip
+  @Keep
+  val status: Double,
+  @DoNotStrip
+  @Keep
+  val isAvailable: Boolean
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(status: Double, isAvailable: Boolean): GooglePlayServicesStatus {
+      return GooglePlayServicesStatus(status, isAvailable)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativedeviceutils/HybridReactNativeDeviceUtilsSpec.kt

@@ -86,6 +86,42 @@ abstract class HybridReactNativeDeviceUtilsSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun setUserInterfaceStyle(style: UserInterfaceStyle): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getLaunchOptions(): Promise<LaunchOptions>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun clearLaunchOptions(): Promise<Boolean>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getDeviceToken(): Promise<String>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun saveDeviceToken(token: String): Promise<Unit>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun registerDeviceToken(): Promise<Boolean>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getStartupTime(): Promise<Double>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun exitApp(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getCurrentWebViewPackageInfo(): Promise<WebViewPackageInfo>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun isGooglePlayServicesAvailable(): Promise<GooglePlayServicesStatus>
 
   private external fun initHybrid(): HybridData
 

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativedeviceutils/LaunchOptions.kt

@@ -0,0 +1,41 @@
+///
+/// LaunchOptions.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativedeviceutils
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "LaunchOptions".
+ */
+@DoNotStrip
+@Keep
+data class LaunchOptions(
+  @DoNotStrip
+  @Keep
+  val launchType: String,
+  @DoNotStrip
+  @Keep
+  val deepLink: String?
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(launchType: String, deepLink: String?): LaunchOptions {
+      return LaunchOptions(launchType, deepLink)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativedeviceutils/WebViewPackageInfo.kt

@@ -0,0 +1,44 @@
+///
+/// WebViewPackageInfo.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativedeviceutils
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "WebViewPackageInfo".
+ */
+@DoNotStrip
+@Keep
+data class WebViewPackageInfo(
+  @DoNotStrip
+  @Keep
+  val packageName: String,
+  @DoNotStrip
+  @Keep
+  val versionName: String,
+  @DoNotStrip
+  @Keep
+  val versionCode: Double
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(packageName: String, versionName: String, versionCode: Double): WebViewPackageInfo {
+      return WebViewPackageInfo(packageName, versionName, versionCode)
+    }
+  }
+}

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

@@ -46,6 +46,54 @@ namespace margelo::nitro::reactnativedeviceutils::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const LaunchOptions& /* result */)>
+  Func_void_LaunchOptions create_Func_void_LaunchOptions(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeDeviceUtils::Func_void_LaunchOptions::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const LaunchOptions& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* result */)>
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeDeviceUtils::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::string& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void()>
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeDeviceUtils::Func_void::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
+      swiftClosure.call();
+    };
+  }
+  
+  // pragma MARK: std::function<void(double /* result */)>
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeDeviceUtils::Func_void_double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](double result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const WebViewPackageInfo& /* result */)>
+  Func_void_WebViewPackageInfo create_Func_void_WebViewPackageInfo(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeDeviceUtils::Func_void_WebViewPackageInfo::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const WebViewPackageInfo& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const GooglePlayServicesStatus& /* result */)>
+  Func_void_GooglePlayServicesStatus create_Func_void_GooglePlayServicesStatus(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeDeviceUtils::Func_void_GooglePlayServicesStatus::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const GooglePlayServicesStatus& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridReactNativeDeviceUtilsSpec>
   std::shared_ptr<HybridReactNativeDeviceUtilsSpec> create_std__shared_ptr_HybridReactNativeDeviceUtilsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeDeviceUtils::HybridReactNativeDeviceUtilsSpec_cxx swiftPart = ReactNativeDeviceUtils::HybridReactNativeDeviceUtilsSpec_cxx::fromUnsafe(swiftUnsafePointer);

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