one 2.6.18 → 2.6.19

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

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AndroidHaptic` to properly resolve imports.
+namespace margelo::nitro::one { enum class AndroidHaptic; }
 // Forward declaration of `AppIntentInvocation` to properly resolve imports.
 namespace margelo::nitro::one { struct AppIntentInvocation; }
 // Forward declaration of `AppTrackingPermissionStatus` to properly resolve imports.
@@ -96,6 +98,8 @@ namespace margelo::nitro::one { struct CalendarEventChanges; }
 namespace margelo::nitro::one { struct CalendarEventInput; }
 // Forward declaration of `CalendarEvent` to properly resolve imports.
 namespace margelo::nitro::one { struct CalendarEvent; }
+// Forward declaration of `CalendarInfo` to properly resolve imports.
+namespace margelo::nitro::one { struct CalendarInfo; }
 // Forward declaration of `CalendarPermissionStatus` to properly resolve imports.
 namespace margelo::nitro::one { enum class CalendarPermissionStatus; }
 // Forward declaration of `CalendarRecurrenceFrequency` to properly resolve imports.
@@ -336,6 +340,8 @@ namespace margelo::nitro::one { struct ListedEntry; }
 namespace margelo::nitro::one { struct LocalAuthenticationStatus; }
 // Forward declaration of `LocalBiometryType` to properly resolve imports.
 namespace margelo::nitro::one { enum class LocalBiometryType; }
+// Forward declaration of `LocaleInfo` to properly resolve imports.
+namespace margelo::nitro::one { struct LocaleInfo; }
 // Forward declaration of `LocalizationInfo` to properly resolve imports.
 namespace margelo::nitro::one { struct LocalizationInfo; }
 // Forward declaration of `LocationPermissionStatus` to properly resolve imports.
@@ -345,9 +351,9 @@ namespace margelo::nitro::one { struct LocationPlace; }
 // Forward declaration of `LocationPosition` to properly resolve imports.
 namespace margelo::nitro::one { struct LocationPosition; }
 // Forward declaration of `LocationRegion` to properly resolve imports.
+namespace margelo::nitro::one { struct LocationRegion; }
 // Forward declaration of `MailComposeResult` to properly resolve imports.
 namespace margelo::nitro::one { enum class MailComposeResult; }
-namespace margelo::nitro::one { struct LocationRegion; }
 // Forward declaration of `MapCoordinate` to properly resolve imports.
 namespace margelo::nitro::one { struct MapCoordinate; }
 // Forward declaration of `MapPlace` to properly resolve imports.
@@ -418,6 +424,8 @@ namespace margelo::nitro::one { struct NetworkState; }
 namespace margelo::nitro::one { struct NotificationBehavior; }
 // Forward declaration of `NotificationPermissionStatus` to properly resolve imports.
 namespace margelo::nitro::one { enum class NotificationPermissionStatus; }
+// Forward declaration of `OneImageFlip` to properly resolve imports.
+namespace margelo::nitro::one { enum class OneImageFlip; }
 // Forward declaration of `OneImageFormat` to properly resolve imports.
 namespace margelo::nitro::one { enum class OneImageFormat; }
 // Forward declaration of `OneUpdatesCheckResult` to properly resolve imports.
@@ -492,6 +500,10 @@ namespace margelo::nitro::one { enum class ScreenCaptureState; }
 namespace margelo::nitro::one { enum class ScreenOrientationLock; }
 // Forward declaration of `ScreenOrientationValue` to properly resolve imports.
 namespace margelo::nitro::one { enum class ScreenOrientationValue; }
+// Forward declaration of `SecureStoreAccessibility` to properly resolve imports.
+namespace margelo::nitro::one { enum class SecureStoreAccessibility; }
+// Forward declaration of `SecureStoreOptions` to properly resolve imports.
+namespace margelo::nitro::one { struct SecureStoreOptions; }
 // Forward declaration of `ShareItemType` to properly resolve imports.
 namespace margelo::nitro::one { enum class ShareItemType; }
 // Forward declaration of `ShareItem` to properly resolve imports.
@@ -526,6 +538,7 @@ namespace margelo::nitro::one { struct SpeechSynthesisVoice; }
 namespace margelo::nitro::one { enum class UserInterfaceSizeClass; }
 
 // Include C++ defined types
+#include "AndroidHaptic.hpp"
 #include "AppIntentInvocation.hpp"
 #include "AppTrackingPermissionStatus.hpp"
 #include "AppleAuthCredential.hpp"
@@ -570,6 +583,7 @@ namespace margelo::nitro::one { enum class UserInterfaceSizeClass; }
 #include "CalendarEvent.hpp"
 #include "CalendarEventChanges.hpp"
 #include "CalendarEventInput.hpp"
+#include "CalendarInfo.hpp"
 #include "CalendarPermissionStatus.hpp"
 #include "CalendarRecurrence.hpp"
 #include "CalendarRecurrenceFrequency.hpp"
@@ -690,6 +704,7 @@ namespace margelo::nitro::one { enum class UserInterfaceSizeClass; }
 #include "ListedEntry.hpp"
 #include "LocalAuthenticationStatus.hpp"
 #include "LocalBiometryType.hpp"
+#include "LocaleInfo.hpp"
 #include "LocalizationInfo.hpp"
 #include "LocationPermissionStatus.hpp"
 #include "LocationPlace.hpp"
@@ -731,6 +746,7 @@ namespace margelo::nitro::one { enum class UserInterfaceSizeClass; }
 #include "NetworkStateType.hpp"
 #include "NotificationBehavior.hpp"
 #include "NotificationPermissionStatus.hpp"
+#include "OneImageFlip.hpp"
 #include "OneImageFormat.hpp"
 #include "OneUpdatesCheckResult.hpp"
 #include "OneUpdatesCheckType.hpp"
@@ -768,6 +784,8 @@ namespace margelo::nitro::one { enum class UserInterfaceSizeClass; }
 #include "ScreenCaptureState.hpp"
 #include "ScreenOrientationLock.hpp"
 #include "ScreenOrientationValue.hpp"
+#include "SecureStoreAccessibility.hpp"
+#include "SecureStoreOptions.hpp"
 #include "ShareItem.hpp"
 #include "ShareItemType.hpp"
 #include "ShareResult.hpp"

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

@@ -16,6 +16,10 @@ namespace One { class HybridOneDeviceSpec_cxx; }
 namespace margelo::nitro::one { struct DeviceInfo; }
 // Forward declaration of `LocalizationInfo` to properly resolve imports.
 namespace margelo::nitro::one { struct LocalizationInfo; }
+// Forward declaration of `LocaleInfo` to properly resolve imports.
+namespace margelo::nitro::one { struct LocaleInfo; }
+// Forward declaration of `CalendarInfo` to properly resolve imports.
+namespace margelo::nitro::one { struct CalendarInfo; }
 
 #include "DeviceInfo.hpp"
 #include <NitroModules/Promise.hpp>
@@ -23,6 +27,9 @@ namespace margelo::nitro::one { struct LocalizationInfo; }
 #include <optional>
 #include "LocalizationInfo.hpp"
 #include <vector>
+#include "LocaleInfo.hpp"
+#include "CalendarInfo.hpp"
+#include <functional>
 
 #include "One-Swift-Cxx-Umbrella.hpp"
 
@@ -90,6 +97,30 @@ namespace margelo::nitro::one {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::vector<LocaleInfo> getLocales() override {
+      auto __result = _swiftPart.getLocales();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<CalendarInfo> getCalendars() override {
+      auto __result = _swiftPart.getCalendars();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> addLocalizationListener(const std::function<void()>& listener) override {
+      auto __result = _swiftPart.addLocalizationListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     One::HybridOneDeviceSpec_cxx _swiftPart;

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

@@ -16,9 +16,12 @@ namespace One { class HybridOneHapticsSpec_cxx; }
 namespace margelo::nitro::one { enum class HapticImpact; }
 // Forward declaration of `HapticNotification` to properly resolve imports.
 namespace margelo::nitro::one { enum class HapticNotification; }
+// Forward declaration of `AndroidHaptic` to properly resolve imports.
+namespace margelo::nitro::one { enum class AndroidHaptic; }
 
 #include "HapticImpact.hpp"
 #include "HapticNotification.hpp"
+#include "AndroidHaptic.hpp"
 
 #include "One-Swift-Cxx-Umbrella.hpp"
 
@@ -88,6 +91,12 @@ namespace margelo::nitro::one {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void performAndroidHaptics(AndroidHaptic type) override {
+      auto __result = _swiftPart.performAndroidHaptics(static_cast<int>(type));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
 
   private:
     One::HybridOneHapticsSpec_cxx _swiftPart;

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

@@ -20,6 +20,8 @@ namespace margelo::nitro::one { struct ImageTransformOptions; }
 namespace margelo::nitro::one { struct ImageCrop; }
 // Forward declaration of `ImageResize` to properly resolve imports.
 namespace margelo::nitro::one { struct ImageResize; }
+// Forward declaration of `OneImageFlip` to properly resolve imports.
+namespace margelo::nitro::one { enum class OneImageFlip; }
 // Forward declaration of `OneImageFormat` to properly resolve imports.
 namespace margelo::nitro::one { enum class OneImageFormat; }
 
@@ -30,6 +32,7 @@ namespace margelo::nitro::one { enum class OneImageFormat; }
 #include "ImageCrop.hpp"
 #include <optional>
 #include "ImageResize.hpp"
+#include "OneImageFlip.hpp"
 #include "OneImageFormat.hpp"
 
 #include "One-Swift-Cxx-Umbrella.hpp"
@@ -78,7 +81,7 @@ namespace margelo::nitro::one {
 
   public:
     // Properties
-
+    
 
   public:
     // Methods

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

@@ -15,6 +15,7 @@ namespace One { class HybridOneKeepAwakeSpec_cxx; }
 
 
 #include <NitroModules/Promise.hpp>
+#include <string>
 
 #include "One-Swift-Cxx-Umbrella.hpp"
 
@@ -62,7 +63,7 @@ namespace margelo::nitro::one {
 
   public:
     // Properties
-
+    
 
   public:
     // Methods
@@ -82,6 +83,22 @@ namespace margelo::nitro::one {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<void>> activate(const std::string& tag) override {
+      auto __result = _swiftPart.activate(tag);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> deactivate(const std::string& tag) override {
+      auto __result = _swiftPart.deactivate(tag);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     One::HybridOneKeepAwakeSpec_cxx _swiftPart;

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

@@ -12,11 +12,16 @@
 // Forward declaration of `HybridOneSecureStoreSpec_cxx` to properly resolve imports.
 namespace One { class HybridOneSecureStoreSpec_cxx; }
 
-
+// Forward declaration of `SecureStoreOptions` to properly resolve imports.
+namespace margelo::nitro::one { struct SecureStoreOptions; }
+// Forward declaration of `SecureStoreAccessibility` to properly resolve imports.
+namespace margelo::nitro::one { enum class SecureStoreAccessibility; }
 
 #include <string>
 #include <optional>
 #include <NitroModules/Promise.hpp>
+#include "SecureStoreOptions.hpp"
+#include "SecureStoreAccessibility.hpp"
 
 #include "One-Swift-Cxx-Umbrella.hpp"
 
@@ -68,46 +73,46 @@ namespace margelo::nitro::one {
 
   public:
     // Methods
-    inline std::shared_ptr<Promise<std::optional<std::string>>> getItem(const std::string& key) override {
-      auto __result = _swiftPart.getItem(key);
+    inline std::shared_ptr<Promise<std::optional<std::string>>> getItem(const std::string& key, const SecureStoreOptions& options) override {
+      auto __result = _swiftPart.getItem(key, std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<void>> setItem(const std::string& key, const std::string& value) override {
-      auto __result = _swiftPart.setItem(key, value);
+    inline std::shared_ptr<Promise<void>> setItem(const std::string& key, const std::string& value, const SecureStoreOptions& options) override {
+      auto __result = _swiftPart.setItem(key, value, std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<void>> deleteItem(const std::string& key) override {
-      auto __result = _swiftPart.deleteItem(key);
+    inline std::shared_ptr<Promise<void>> deleteItem(const std::string& key, const SecureStoreOptions& options) override {
+      auto __result = _swiftPart.deleteItem(key, std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::optional<std::string> getItemSync(const std::string& key) override {
-      auto __result = _swiftPart.getItemSync(key);
+    inline std::optional<std::string> getItemSync(const std::string& key, const SecureStoreOptions& options) override {
+      auto __result = _swiftPart.getItemSync(key, std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void setItemSync(const std::string& key, const std::string& value) override {
-      auto __result = _swiftPart.setItemSync(key, value);
+    inline void setItemSync(const std::string& key, const std::string& value, const SecureStoreOptions& options) override {
+      auto __result = _swiftPart.setItemSync(key, value, std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
-    inline void deleteItemSync(const std::string& key) override {
-      auto __result = _swiftPart.deleteItemSync(key);
+    inline void deleteItemSync(const std::string& key, const SecureStoreOptions& options) override {
+      auto __result = _swiftPart.deleteItemSync(key, std::forward<decltype(options)>(options));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

package/nitrogen/generated/ios/swift/AndroidHaptic.swift

@@ -0,0 +1,108 @@
+///
+/// AndroidHaptic.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `AndroidHaptic`, backed by a C++ enum.
+ */
+public typealias AndroidHaptic = margelo.nitro.one.AndroidHaptic
+
+public extension AndroidHaptic {
+  /**
+   * Get a AndroidHaptic for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "clock-tick":
+        self = .clockTick
+      case "confirm":
+        self = .confirm
+      case "context-click":
+        self = .contextClick
+      case "drag-start":
+        self = .dragStart
+      case "gesture-end":
+        self = .gestureEnd
+      case "gesture-start":
+        self = .gestureStart
+      case "keyboard-press":
+        self = .keyboardPress
+      case "keyboard-release":
+        self = .keyboardRelease
+      case "keyboard-tap":
+        self = .keyboardTap
+      case "long-press":
+        self = .longPress
+      case "no-haptics":
+        self = .noHaptics
+      case "reject":
+        self = .reject
+      case "segment-frequent-tick":
+        self = .segmentFrequentTick
+      case "segment-tick":
+        self = .segmentTick
+      case "text-handle-move":
+        self = .textHandleMove
+      case "toggle-off":
+        self = .toggleOff
+      case "toggle-on":
+        self = .toggleOn
+      case "virtual-key":
+        self = .virtualKey
+      case "virtual-key-release":
+        self = .virtualKeyRelease
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AndroidHaptic represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .clockTick:
+        return "clock-tick"
+      case .confirm:
+        return "confirm"
+      case .contextClick:
+        return "context-click"
+      case .dragStart:
+        return "drag-start"
+      case .gestureEnd:
+        return "gesture-end"
+      case .gestureStart:
+        return "gesture-start"
+      case .keyboardPress:
+        return "keyboard-press"
+      case .keyboardRelease:
+        return "keyboard-release"
+      case .keyboardTap:
+        return "keyboard-tap"
+      case .longPress:
+        return "long-press"
+      case .noHaptics:
+        return "no-haptics"
+      case .reject:
+        return "reject"
+      case .segmentFrequentTick:
+        return "segment-frequent-tick"
+      case .segmentTick:
+        return "segment-tick"
+      case .textHandleMove:
+        return "text-handle-move"
+      case .toggleOff:
+        return "toggle-off"
+      case .toggleOn:
+        return "toggle-on"
+      case .virtualKey:
+        return "virtual-key"
+      case .virtualKeyRelease:
+        return "virtual-key-release"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/CalendarInfo.swift

@@ -0,0 +1,96 @@
+///
+/// CalendarInfo.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `CalendarInfo`, backed by a C++ struct.
+ */
+public typealias CalendarInfo = margelo.nitro.one.CalendarInfo
+
+public extension CalendarInfo {
+  private typealias bridge = margelo.nitro.one.bridge.swift
+
+  /**
+   * Create a new instance of `CalendarInfo`.
+   */
+  init(calendar: String?, timeZone: String?, uses24hourClock: Bool?, firstWeekday: Double?) {
+    self.init({ () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = calendar {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = timeZone {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = uses24hourClock {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = firstWeekday {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var calendar: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__calendar) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__calendar)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var timeZone: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__timeZone) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__timeZone)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var uses24hourClock: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__uses24hourClock) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__uses24hourClock)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var firstWeekday: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__firstWeekday) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__firstWeekday)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+}

package/nitrogen/generated/ios/swift/HapticImpact.swift

@@ -17,10 +17,10 @@ public extension HapticImpact {
    */
   init?(fromString string: String) {
     switch string {
-      case "light":
-        self = .light
       case "medium":
         self = .medium
+      case "light":
+        self = .light
       case "heavy":
         self = .heavy
       case "soft":
@@ -37,10 +37,10 @@ public extension HapticImpact {
    */
   var stringValue: String {
     switch self {
-      case .light:
-        return "light"
       case .medium:
         return "medium"
+      case .light:
+        return "light"
       case .heavy:
         return "heavy"
       case .soft:

package/nitrogen/generated/ios/swift/HybridOneDeviceSpec.swift

@@ -15,6 +15,9 @@ public protocol HybridOneDeviceSpec_protocol: HybridObject {
   // Methods
   func getInfo() throws -> Promise<DeviceInfo>
   func getLocalizationInfo() throws -> Promise<LocalizationInfo>
+  func getLocales() throws -> [LocaleInfo]
+  func getCalendars() throws -> [CalendarInfo]
+  func addLocalizationListener(listener: @escaping () -> Void) throws -> () -> Void
 }
 
 public extension HybridOneDeviceSpec_protocol {

package/nitrogen/generated/ios/swift/HybridOneDeviceSpec_cxx.swift

@@ -161,4 +161,60 @@ open class HybridOneDeviceSpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_LocalizationInfo___(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func getLocales() -> bridge.Result_std__vector_LocaleInfo__ {
+    do {
+      let __result = try self.__implementation.getLocales()
+      let __resultCpp = { () -> bridge.std__vector_LocaleInfo_ in
+        var __vector = bridge.create_std__vector_LocaleInfo_(__result.count)
+        for __item in __result {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_LocaleInfo__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_LocaleInfo__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getCalendars() -> bridge.Result_std__vector_CalendarInfo__ {
+    do {
+      let __result = try self.__implementation.getCalendars()
+      let __resultCpp = { () -> bridge.std__vector_CalendarInfo_ in
+        var __vector = bridge.create_std__vector_CalendarInfo_(__result.count)
+        for __item in __result {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_CalendarInfo__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_CalendarInfo__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func addLocalizationListener(listener: bridge.Func_void) -> bridge.Result_std__function_void____ {
+    do {
+      let __result = try self.__implementation.addLocalizationListener(listener: { () -> () -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void(listener)
+        return { () -> Void in
+          __wrappedFunction.call()
+        }
+      }())
+      let __resultCpp = { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(__result)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+      return bridge.create_Result_std__function_void____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__function_void____(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/ios/swift/HybridOneHapticsSpec.swift

@@ -16,6 +16,7 @@ public protocol HybridOneHapticsSpec_protocol: HybridObject {
   func selection() throws -> Void
   func impact(style: HapticImpact) throws -> Void
   func notification(type: HapticNotification) throws -> Void
+  func performAndroidHaptics(type: AndroidHaptic) throws -> Void
 }
 
 public extension HybridOneHapticsSpec_protocol {

package/nitrogen/generated/ios/swift/HybridOneHapticsSpec_cxx.swift

@@ -156,4 +156,15 @@ open class HybridOneHapticsSpec_cxx {
       return bridge.create_Result_void_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func performAndroidHaptics(type: Int32) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.performAndroidHaptics(type: margelo.nitro.one.AndroidHaptic(rawValue: type)!)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/ios/swift/HybridOneKeepAwakeSpec.swift

@@ -10,11 +10,13 @@ import NitroModules
 /// See ``HybridOneKeepAwakeSpec``
 public protocol HybridOneKeepAwakeSpec_protocol: HybridObject {
   // Properties
-
+  
 
   // Methods
   func isEnabled() throws -> Promise<Bool>
   func setEnabled(enabled: Bool) throws -> Promise<Void>
+  func activate(tag: String) throws -> Promise<Void>
+  func deactivate(tag: String) throws -> Promise<Void>
 }
 
 public extension HybridOneKeepAwakeSpec_protocol {