@abeman/react-native-nitro-blur 0.1.0

package/nitrogen/generated/ios/swift/HybridNitroBlurSpec_cxx.swift

@@ -0,0 +1,200 @@
+///
+/// HybridNitroBlurSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridNitroBlurSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridNitroBlurSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::nitroblur::bridge::swift`)
+   * from `NitroBlur-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.nitroblur.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridNitroBlurSpec` Swift protocol.
+   */
+  private var __implementation: any HybridNitroBlurSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridNitroBlurSpec_
+
+  /**
+   * Create a new `HybridNitroBlurSpec_cxx` that wraps the given `HybridNitroBlurSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridNitroBlurSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridNitroBlurSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridNitroBlurSpec() -> any HybridNitroBlurSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridNitroBlurSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridNitroBlurSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridNitroBlurSpec_cxx {
+    return Unmanaged<HybridNitroBlurSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridNitroBlurSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridNitroBlurSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridNitroBlurSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridNitroBlurSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridNitroBlurSpec_cxx) -> Bool {
+    return self.__implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  public final var tint: Int32 {
+    @inline(__always)
+    get {
+      return self.__implementation.tint.rawValue
+    }
+    @inline(__always)
+    set {
+      self.__implementation.tint = margelo.nitro.nitroblur.BlurTint(rawValue: newValue)!
+    }
+  }
+  
+  public final var intensity: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.intensity
+    }
+    @inline(__always)
+    set {
+      self.__implementation.intensity = newValue
+    }
+  }
+  
+  public final var blurReductionFactor: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.blurReductionFactor
+    }
+    @inline(__always)
+    set {
+      self.__implementation.blurReductionFactor = newValue
+    }
+  }
+  
+  public final var blurTargetId: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.blurTargetId
+    }
+    @inline(__always)
+    set {
+      self.__implementation.blurTargetId = newValue
+    }
+  }
+  
+  public final var blurMethod: Int32 {
+    @inline(__always)
+    get {
+      return self.__implementation.blurMethod.rawValue
+    }
+    @inline(__always)
+    set {
+      self.__implementation.blurMethod = margelo.nitro.nitroblur.BlurMethod(rawValue: newValue)!
+    }
+  }
+
+  // Methods
+  public final func getView() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(__implementation.view).toOpaque()
+  }
+  
+  public final func beforeUpdate() {
+    __implementation.beforeUpdate()
+  }
+  
+  public final func afterUpdate() {
+    __implementation.afterUpdate()
+  }
+  
+  public final func maybePrepareForRecycle() {
+    guard let recyclable = __implementation as? any RecyclableView else { return }
+    recyclable.prepareForRecycle()
+  }
+  
+  public final func onDropView() {
+    __implementation.onDropView()
+  }
+}

package/nitrogen/generated/ios/swift/HybridNitroBlurTargetSpec.swift

@@ -0,0 +1,55 @@
+///
+/// HybridNitroBlurTargetSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// See ``HybridNitroBlurTargetSpec``
+public protocol HybridNitroBlurTargetSpec_protocol: HybridObject, HybridView {
+  // Properties
+  
+
+  // Methods
+  
+}
+
+public extension HybridNitroBlurTargetSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject NitroBlurTarget]"
+  }
+}
+
+/// See ``HybridNitroBlurTargetSpec``
+open class HybridNitroBlurTargetSpec_base {
+  private weak var cxxWrapper: HybridNitroBlurTargetSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridNitroBlurTargetSpec_cxx {
+  #if DEBUG
+    guard self is any HybridNitroBlurTargetSpec else {
+      fatalError("`self` is not a `HybridNitroBlurTargetSpec`! Did you accidentally inherit from `HybridNitroBlurTargetSpec_base` instead of `HybridNitroBlurTargetSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridNitroBlurTargetSpec_cxx(self as! any HybridNitroBlurTargetSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the NitroBlurTarget HybridObject.
+ * Implement this protocol to create Swift-based instances of NitroBlurTarget.
+ * ```swift
+ * class HybridNitroBlurTarget : HybridNitroBlurTargetSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridNitroBlurTargetSpec = HybridNitroBlurTargetSpec_protocol & HybridNitroBlurTargetSpec_base

package/nitrogen/generated/ios/swift/HybridNitroBlurTargetSpec_cxx.swift

@@ -0,0 +1,147 @@
+///
+/// HybridNitroBlurTargetSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridNitroBlurTargetSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridNitroBlurTargetSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::nitroblur::bridge::swift`)
+   * from `NitroBlur-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.nitroblur.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridNitroBlurTargetSpec` Swift protocol.
+   */
+  private var __implementation: any HybridNitroBlurTargetSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridNitroBlurTargetSpec_
+
+  /**
+   * Create a new `HybridNitroBlurTargetSpec_cxx` that wraps the given `HybridNitroBlurTargetSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridNitroBlurTargetSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridNitroBlurTargetSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridNitroBlurTargetSpec() -> any HybridNitroBlurTargetSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridNitroBlurTargetSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridNitroBlurTargetSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridNitroBlurTargetSpec_cxx {
+    return Unmanaged<HybridNitroBlurTargetSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridNitroBlurTargetSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridNitroBlurTargetSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridNitroBlurTargetSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridNitroBlurTargetSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridNitroBlurTargetSpec_cxx) -> Bool {
+    return self.__implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  
+
+  // Methods
+  public final func getView() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(__implementation.view).toOpaque()
+  }
+  
+  public final func beforeUpdate() {
+    __implementation.beforeUpdate()
+  }
+  
+  public final func afterUpdate() {
+    __implementation.afterUpdate()
+  }
+  
+  public final func maybePrepareForRecycle() {
+    guard let recyclable = __implementation as? any RecyclableView else { return }
+    recyclable.prepareForRecycle()
+  }
+  
+  public final func onDropView() {
+    __implementation.onDropView()
+  }
+}

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

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

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

@@ -0,0 +1,152 @@
+///
+/// BlurTint.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::nitroblur {
+
+  /**
+   * An enum which can be represented as a JavaScript union (BlurTint).
+   */
+  enum class BlurTint {
+    LIGHT      SWIFT_NAME(light) = 0,
+    DARK      SWIFT_NAME(dark) = 1,
+    DEFAULT      SWIFT_NAME(default) = 2,
+    EXTRALIGHT      SWIFT_NAME(extralight) = 3,
+    REGULAR      SWIFT_NAME(regular) = 4,
+    PROMINENT      SWIFT_NAME(prominent) = 5,
+    SYSTEMULTRATHINMATERIAL      SWIFT_NAME(systemultrathinmaterial) = 6,
+    SYSTEMTHINMATERIAL      SWIFT_NAME(systemthinmaterial) = 7,
+    SYSTEMMATERIAL      SWIFT_NAME(systemmaterial) = 8,
+    SYSTEMTHICKMATERIAL      SWIFT_NAME(systemthickmaterial) = 9,
+    SYSTEMCHROMEMATERIAL      SWIFT_NAME(systemchromematerial) = 10,
+    SYSTEMULTRATHINMATERIALLIGHT      SWIFT_NAME(systemultrathinmateriallight) = 11,
+    SYSTEMTHINMATERIALLIGHT      SWIFT_NAME(systemthinmateriallight) = 12,
+    SYSTEMMATERIALLIGHT      SWIFT_NAME(systemmateriallight) = 13,
+    SYSTEMTHICKMATERIALLIGHT      SWIFT_NAME(systemthickmateriallight) = 14,
+    SYSTEMCHROMEMATERIALLIGHT      SWIFT_NAME(systemchromemateriallight) = 15,
+    SYSTEMULTRATHINMATERIALDARK      SWIFT_NAME(systemultrathinmaterialdark) = 16,
+    SYSTEMTHINMATERIALDARK      SWIFT_NAME(systemthinmaterialdark) = 17,
+    SYSTEMMATERIALDARK      SWIFT_NAME(systemmaterialdark) = 18,
+    SYSTEMTHICKMATERIALDARK      SWIFT_NAME(systemthickmaterialdark) = 19,
+    SYSTEMCHROMEMATERIALDARK      SWIFT_NAME(systemchromematerialdark) = 20,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitroblur
+
+namespace margelo::nitro {
+
+  // C++ BlurTint <> JS BlurTint (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitroblur::BlurTint> final {
+    static inline margelo::nitro::nitroblur::BlurTint fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("light"): return margelo::nitro::nitroblur::BlurTint::LIGHT;
+        case hashString("dark"): return margelo::nitro::nitroblur::BlurTint::DARK;
+        case hashString("default"): return margelo::nitro::nitroblur::BlurTint::DEFAULT;
+        case hashString("extraLight"): return margelo::nitro::nitroblur::BlurTint::EXTRALIGHT;
+        case hashString("regular"): return margelo::nitro::nitroblur::BlurTint::REGULAR;
+        case hashString("prominent"): return margelo::nitro::nitroblur::BlurTint::PROMINENT;
+        case hashString("systemUltraThinMaterial"): return margelo::nitro::nitroblur::BlurTint::SYSTEMULTRATHINMATERIAL;
+        case hashString("systemThinMaterial"): return margelo::nitro::nitroblur::BlurTint::SYSTEMTHINMATERIAL;
+        case hashString("systemMaterial"): return margelo::nitro::nitroblur::BlurTint::SYSTEMMATERIAL;
+        case hashString("systemThickMaterial"): return margelo::nitro::nitroblur::BlurTint::SYSTEMTHICKMATERIAL;
+        case hashString("systemChromeMaterial"): return margelo::nitro::nitroblur::BlurTint::SYSTEMCHROMEMATERIAL;
+        case hashString("systemUltraThinMaterialLight"): return margelo::nitro::nitroblur::BlurTint::SYSTEMULTRATHINMATERIALLIGHT;
+        case hashString("systemThinMaterialLight"): return margelo::nitro::nitroblur::BlurTint::SYSTEMTHINMATERIALLIGHT;
+        case hashString("systemMaterialLight"): return margelo::nitro::nitroblur::BlurTint::SYSTEMMATERIALLIGHT;
+        case hashString("systemThickMaterialLight"): return margelo::nitro::nitroblur::BlurTint::SYSTEMTHICKMATERIALLIGHT;
+        case hashString("systemChromeMaterialLight"): return margelo::nitro::nitroblur::BlurTint::SYSTEMCHROMEMATERIALLIGHT;
+        case hashString("systemUltraThinMaterialDark"): return margelo::nitro::nitroblur::BlurTint::SYSTEMULTRATHINMATERIALDARK;
+        case hashString("systemThinMaterialDark"): return margelo::nitro::nitroblur::BlurTint::SYSTEMTHINMATERIALDARK;
+        case hashString("systemMaterialDark"): return margelo::nitro::nitroblur::BlurTint::SYSTEMMATERIALDARK;
+        case hashString("systemThickMaterialDark"): return margelo::nitro::nitroblur::BlurTint::SYSTEMTHICKMATERIALDARK;
+        case hashString("systemChromeMaterialDark"): return margelo::nitro::nitroblur::BlurTint::SYSTEMCHROMEMATERIALDARK;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum BlurTint - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitroblur::BlurTint arg) {
+      switch (arg) {
+        case margelo::nitro::nitroblur::BlurTint::LIGHT: return JSIConverter<std::string>::toJSI(runtime, "light");
+        case margelo::nitro::nitroblur::BlurTint::DARK: return JSIConverter<std::string>::toJSI(runtime, "dark");
+        case margelo::nitro::nitroblur::BlurTint::DEFAULT: return JSIConverter<std::string>::toJSI(runtime, "default");
+        case margelo::nitro::nitroblur::BlurTint::EXTRALIGHT: return JSIConverter<std::string>::toJSI(runtime, "extraLight");
+        case margelo::nitro::nitroblur::BlurTint::REGULAR: return JSIConverter<std::string>::toJSI(runtime, "regular");
+        case margelo::nitro::nitroblur::BlurTint::PROMINENT: return JSIConverter<std::string>::toJSI(runtime, "prominent");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMULTRATHINMATERIAL: return JSIConverter<std::string>::toJSI(runtime, "systemUltraThinMaterial");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMTHINMATERIAL: return JSIConverter<std::string>::toJSI(runtime, "systemThinMaterial");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMMATERIAL: return JSIConverter<std::string>::toJSI(runtime, "systemMaterial");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMTHICKMATERIAL: return JSIConverter<std::string>::toJSI(runtime, "systemThickMaterial");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMCHROMEMATERIAL: return JSIConverter<std::string>::toJSI(runtime, "systemChromeMaterial");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMULTRATHINMATERIALLIGHT: return JSIConverter<std::string>::toJSI(runtime, "systemUltraThinMaterialLight");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMTHINMATERIALLIGHT: return JSIConverter<std::string>::toJSI(runtime, "systemThinMaterialLight");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMMATERIALLIGHT: return JSIConverter<std::string>::toJSI(runtime, "systemMaterialLight");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMTHICKMATERIALLIGHT: return JSIConverter<std::string>::toJSI(runtime, "systemThickMaterialLight");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMCHROMEMATERIALLIGHT: return JSIConverter<std::string>::toJSI(runtime, "systemChromeMaterialLight");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMULTRATHINMATERIALDARK: return JSIConverter<std::string>::toJSI(runtime, "systemUltraThinMaterialDark");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMTHINMATERIALDARK: return JSIConverter<std::string>::toJSI(runtime, "systemThinMaterialDark");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMMATERIALDARK: return JSIConverter<std::string>::toJSI(runtime, "systemMaterialDark");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMTHICKMATERIALDARK: return JSIConverter<std::string>::toJSI(runtime, "systemThickMaterialDark");
+        case margelo::nitro::nitroblur::BlurTint::SYSTEMCHROMEMATERIALDARK: return JSIConverter<std::string>::toJSI(runtime, "systemChromeMaterialDark");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert BlurTint to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("light"):
+        case hashString("dark"):
+        case hashString("default"):
+        case hashString("extraLight"):
+        case hashString("regular"):
+        case hashString("prominent"):
+        case hashString("systemUltraThinMaterial"):
+        case hashString("systemThinMaterial"):
+        case hashString("systemMaterial"):
+        case hashString("systemThickMaterial"):
+        case hashString("systemChromeMaterial"):
+        case hashString("systemUltraThinMaterialLight"):
+        case hashString("systemThinMaterialLight"):
+        case hashString("systemMaterialLight"):
+        case hashString("systemThickMaterialLight"):
+        case hashString("systemChromeMaterialLight"):
+        case hashString("systemUltraThinMaterialDark"):
+        case hashString("systemThinMaterialDark"):
+        case hashString("systemMaterialDark"):
+        case hashString("systemThickMaterialDark"):
+        case hashString("systemChromeMaterialDark"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,30 @@
+///
+/// HybridNitroBlurSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroBlurSpec.hpp"
+
+namespace margelo::nitro::nitroblur {
+
+  void HybridNitroBlurSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("tint", &HybridNitroBlurSpec::getTint);
+      prototype.registerHybridSetter("tint", &HybridNitroBlurSpec::setTint);
+      prototype.registerHybridGetter("intensity", &HybridNitroBlurSpec::getIntensity);
+      prototype.registerHybridSetter("intensity", &HybridNitroBlurSpec::setIntensity);
+      prototype.registerHybridGetter("blurReductionFactor", &HybridNitroBlurSpec::getBlurReductionFactor);
+      prototype.registerHybridSetter("blurReductionFactor", &HybridNitroBlurSpec::setBlurReductionFactor);
+      prototype.registerHybridGetter("blurTargetId", &HybridNitroBlurSpec::getBlurTargetId);
+      prototype.registerHybridSetter("blurTargetId", &HybridNitroBlurSpec::setBlurTargetId);
+      prototype.registerHybridGetter("blurMethod", &HybridNitroBlurSpec::getBlurMethod);
+      prototype.registerHybridSetter("blurMethod", &HybridNitroBlurSpec::setBlurMethod);
+    });
+  }
+
+} // namespace margelo::nitro::nitroblur