@abeman/react-native-nitro-blur 0.1.0

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

@@ -0,0 +1,110 @@
+///
+/// HybridNitroBlurSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNitroBlurSpec.hpp"
+
+// Forward declaration of `HybridNitroBlurSpec_cxx` to properly resolve imports.
+namespace NitroBlur { class HybridNitroBlurSpec_cxx; }
+
+// Forward declaration of `BlurTint` to properly resolve imports.
+namespace margelo::nitro::nitroblur { enum class BlurTint; }
+// Forward declaration of `BlurMethod` to properly resolve imports.
+namespace margelo::nitro::nitroblur { enum class BlurMethod; }
+
+#include "BlurTint.hpp"
+#include "BlurMethod.hpp"
+
+#include "NitroBlur-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitroblur {
+
+  /**
+   * The C++ part of HybridNitroBlurSpec_cxx.swift.
+   *
+   * HybridNitroBlurSpecSwift (C++) accesses HybridNitroBlurSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridNitroBlurSpec_cxx can directly inherit from the C++ class HybridNitroBlurSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNitroBlurSpecSwift: public virtual HybridNitroBlurSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNitroBlurSpecSwift(const NitroBlur::HybridNitroBlurSpec_cxx& swiftPart):
+      HybridObject(HybridNitroBlurSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroBlur::HybridNitroBlurSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridNitroBlurSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline BlurTint getTint() noexcept override {
+      auto __result = _swiftPart.getTint();
+      return static_cast<BlurTint>(__result);
+    }
+    inline void setTint(BlurTint tint) noexcept override {
+      _swiftPart.setTint(static_cast<int>(tint));
+    }
+    inline double getIntensity() noexcept override {
+      return _swiftPart.getIntensity();
+    }
+    inline void setIntensity(double intensity) noexcept override {
+      _swiftPart.setIntensity(std::forward<decltype(intensity)>(intensity));
+    }
+    inline double getBlurReductionFactor() noexcept override {
+      return _swiftPart.getBlurReductionFactor();
+    }
+    inline void setBlurReductionFactor(double blurReductionFactor) noexcept override {
+      _swiftPart.setBlurReductionFactor(std::forward<decltype(blurReductionFactor)>(blurReductionFactor));
+    }
+    inline double getBlurTargetId() noexcept override {
+      return _swiftPart.getBlurTargetId();
+    }
+    inline void setBlurTargetId(double blurTargetId) noexcept override {
+      _swiftPart.setBlurTargetId(std::forward<decltype(blurTargetId)>(blurTargetId));
+    }
+    inline BlurMethod getBlurMethod() noexcept override {
+      auto __result = _swiftPart.getBlurMethod();
+      return static_cast<BlurMethod>(__result);
+    }
+    inline void setBlurMethod(BlurMethod blurMethod) noexcept override {
+      _swiftPart.setBlurMethod(static_cast<int>(blurMethod));
+    }
+
+  public:
+    // Methods
+    
+
+  private:
+    NitroBlur::HybridNitroBlurSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitroblur

package/nitrogen/generated/ios/c++/HybridNitroBlurTargetSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridNitroBlurTargetSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroBlurTargetSpecSwift.hpp"
+
+namespace margelo::nitro::nitroblur {
+} // namespace margelo::nitro::nitroblur

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

@@ -0,0 +1,75 @@
+///
+/// HybridNitroBlurTargetSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNitroBlurTargetSpec.hpp"
+
+// Forward declaration of `HybridNitroBlurTargetSpec_cxx` to properly resolve imports.
+namespace NitroBlur { class HybridNitroBlurTargetSpec_cxx; }
+
+
+
+
+
+#include "NitroBlur-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitroblur {
+
+  /**
+   * The C++ part of HybridNitroBlurTargetSpec_cxx.swift.
+   *
+   * HybridNitroBlurTargetSpecSwift (C++) accesses HybridNitroBlurTargetSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridNitroBlurTargetSpec_cxx can directly inherit from the C++ class HybridNitroBlurTargetSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNitroBlurTargetSpecSwift: public virtual HybridNitroBlurTargetSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNitroBlurTargetSpecSwift(const NitroBlur::HybridNitroBlurTargetSpec_cxx& swiftPart):
+      HybridObject(HybridNitroBlurTargetSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroBlur::HybridNitroBlurTargetSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridNitroBlurTargetSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    
+
+  private:
+    NitroBlur::HybridNitroBlurTargetSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitroblur

package/nitrogen/generated/ios/c++/views/HybridNitroBlurComponent.mm

@@ -0,0 +1,142 @@
+///
+/// HybridNitroBlurComponent.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import "HybridNitroBlurComponent.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "HybridNitroBlurSpecSwift.hpp"
+#import "NitroBlur-Swift-Cxx-Umbrella.hpp"
+
+#if __has_include(<cxxreact/ReactNativeVersion.h>)
+#include <cxxreact/ReactNativeVersion.h>
+#if REACT_NATIVE_VERSION_MINOR >= 82
+#define ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
+#endif
+#endif
+
+using namespace facebook;
+using namespace margelo::nitro::nitroblur;
+using namespace margelo::nitro::nitroblur::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "NitroBlur" HybridView.
+ */
+@interface HybridNitroBlurComponent: RCTViewComponentView
++ (BOOL)shouldBeRecycled;
+@end
+
+@implementation HybridNitroBlurComponent {
+  std::shared_ptr<HybridNitroBlurSpecSwift> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridNitroBlurComponent class]];
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<HybridNitroBlurComponentDescriptor>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<HybridNitroBlurSpec> hybridView = NitroBlur::NitroBlurAutolinking::createNitroBlur();
+    _hybridView = std::dynamic_pointer_cast<HybridNitroBlurSpecSwift>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  NitroBlur::HybridNitroBlurSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<HybridNitroBlurProps const>(props);
+  auto& newViewProps = const_cast<HybridNitroBlurProps&>(newViewPropsConst);
+  NitroBlur::HybridNitroBlurSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  // tint: enum
+  if (newViewProps.tint.isDirty) {
+    swiftPart.setTint(static_cast<int>(newViewProps.tint.value));
+    newViewProps.tint.isDirty = false;
+  }
+  // intensity: number
+  if (newViewProps.intensity.isDirty) {
+    swiftPart.setIntensity(newViewProps.intensity.value);
+    newViewProps.intensity.isDirty = false;
+  }
+  // blurReductionFactor: number
+  if (newViewProps.blurReductionFactor.isDirty) {
+    swiftPart.setBlurReductionFactor(newViewProps.blurReductionFactor.value);
+    newViewProps.blurReductionFactor.isDirty = false;
+  }
+  // blurTargetId: number
+  if (newViewProps.blurTargetId.isDirty) {
+    swiftPart.setBlurTargetId(newViewProps.blurTargetId.value);
+    newViewProps.blurTargetId.isDirty = false;
+  }
+  // blurMethod: enum
+  if (newViewProps.blurMethod.isDirty) {
+    swiftPart.setBlurMethod(static_cast<int>(newViewProps.blurMethod.value));
+    newViewProps.blurMethod.isDirty = false;
+  }
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (BOOL)shouldBeRecycled {
+  return NitroBlur::NitroBlurAutolinking::isNitroBlurRecyclable();
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  NitroBlur::HybridNitroBlurSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.maybePrepareForRecycle();
+}
+
+#ifdef ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
+- (void)invalidate {
+  NitroBlur::HybridNitroBlurSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.onDropView();
+  [super invalidate];
+}
+#endif
+
+@end

package/nitrogen/generated/ios/c++/views/HybridNitroBlurTargetComponent.mm

@@ -0,0 +1,118 @@
+///
+/// HybridNitroBlurTargetComponent.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import "HybridNitroBlurTargetComponent.hpp"
+#import <memory>
+#import <react/renderer/componentregistry/ComponentDescriptorProvider.h>
+#import <React/RCTViewComponentView.h>
+#import <React/RCTComponentViewFactory.h>
+#import <React/UIView+ComponentViewProtocol.h>
+#import <NitroModules/NitroDefines.hpp>
+#import <UIKit/UIKit.h>
+
+#import "HybridNitroBlurTargetSpecSwift.hpp"
+#import "NitroBlur-Swift-Cxx-Umbrella.hpp"
+
+#if __has_include(<cxxreact/ReactNativeVersion.h>)
+#include <cxxreact/ReactNativeVersion.h>
+#if REACT_NATIVE_VERSION_MINOR >= 82
+#define ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
+#endif
+#endif
+
+using namespace facebook;
+using namespace margelo::nitro::nitroblur;
+using namespace margelo::nitro::nitroblur::views;
+
+/**
+ * Represents the React Native View holder for the Nitro "NitroBlurTarget" HybridView.
+ */
+@interface HybridNitroBlurTargetComponent: RCTViewComponentView
++ (BOOL)shouldBeRecycled;
+@end
+
+@implementation HybridNitroBlurTargetComponent {
+  std::shared_ptr<HybridNitroBlurTargetSpecSwift> _hybridView;
+}
+
++ (void) load {
+  [super load];
+  [RCTComponentViewFactory.currentComponentViewFactory registerComponentViewClass:[HybridNitroBlurTargetComponent class]];
+}
+
++ (react::ComponentDescriptorProvider) componentDescriptorProvider {
+  return react::concreteComponentDescriptorProvider<HybridNitroBlurTargetComponentDescriptor>();
+}
+
+- (instancetype) init {
+  if (self = [super init]) {
+    std::shared_ptr<HybridNitroBlurTargetSpec> hybridView = NitroBlur::NitroBlurAutolinking::createNitroBlurTarget();
+    _hybridView = std::dynamic_pointer_cast<HybridNitroBlurTargetSpecSwift>(hybridView);
+    [self updateView];
+  }
+  return self;
+}
+
+- (void) updateView {
+  // 1. Get Swift part
+  NitroBlur::HybridNitroBlurTargetSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Get UIView*
+  void* viewUnsafe = swiftPart.getView();
+  UIView* view = (__bridge_transfer UIView*) viewUnsafe;
+
+  // 3. Update RCTViewComponentView's [contentView]
+  [self setContentView:view];
+}
+
+- (void) updateProps:(const std::shared_ptr<const react::Props>&)props
+            oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // 1. Downcast props
+  const auto& newViewPropsConst = *std::static_pointer_cast<HybridNitroBlurTargetProps const>(props);
+  auto& newViewProps = const_cast<HybridNitroBlurTargetProps&>(newViewPropsConst);
+  NitroBlur::HybridNitroBlurTargetSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+
+  // 2. Update each prop individually
+  swiftPart.beforeUpdate();
+
+  
+
+  swiftPart.afterUpdate();
+
+  // 3. Update hybridRef if it changed
+  if (newViewProps.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newViewProps.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(_hybridView);
+    }
+    newViewProps.hybridRef.isDirty = false;
+  }
+
+  // 4. Continue in base class
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (BOOL)shouldBeRecycled {
+  return NitroBlur::NitroBlurAutolinking::isNitroBlurTargetRecyclable();
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  NitroBlur::HybridNitroBlurTargetSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.maybePrepareForRecycle();
+}
+
+#ifdef ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
+- (void)invalidate {
+  NitroBlur::HybridNitroBlurTargetSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.onDropView();
+  [super invalidate];
+}
+#endif
+
+@end

package/nitrogen/generated/ios/swift/BlurMethod.swift

@@ -0,0 +1,44 @@
+///
+/// BlurMethod.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 `BlurMethod`, backed by a C++ enum.
+ */
+public typealias BlurMethod = margelo.nitro.nitroblur.BlurMethod
+
+public extension BlurMethod {
+  /**
+   * Get a BlurMethod for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "none":
+        self = .none
+      case "dimezisBlurView":
+        self = .dimezisblurview
+      case "dimezisBlurViewSdk31Plus":
+        self = .dimezisblurviewsdk31plus
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this BlurMethod represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .none:
+        return "none"
+      case .dimezisblurview:
+        return "dimezisBlurView"
+      case .dimezisblurviewsdk31plus:
+        return "dimezisBlurViewSdk31Plus"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/BlurTint.swift

@@ -0,0 +1,116 @@
+///
+/// BlurTint.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 `BlurTint`, backed by a C++ enum.
+ */
+public typealias BlurTint = margelo.nitro.nitroblur.BlurTint
+
+public extension BlurTint {
+  /**
+   * Get a BlurTint for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "light":
+        self = .light
+      case "dark":
+        self = .dark
+      case "default":
+        self = .default
+      case "extraLight":
+        self = .extralight
+      case "regular":
+        self = .regular
+      case "prominent":
+        self = .prominent
+      case "systemUltraThinMaterial":
+        self = .systemultrathinmaterial
+      case "systemThinMaterial":
+        self = .systemthinmaterial
+      case "systemMaterial":
+        self = .systemmaterial
+      case "systemThickMaterial":
+        self = .systemthickmaterial
+      case "systemChromeMaterial":
+        self = .systemchromematerial
+      case "systemUltraThinMaterialLight":
+        self = .systemultrathinmateriallight
+      case "systemThinMaterialLight":
+        self = .systemthinmateriallight
+      case "systemMaterialLight":
+        self = .systemmateriallight
+      case "systemThickMaterialLight":
+        self = .systemthickmateriallight
+      case "systemChromeMaterialLight":
+        self = .systemchromemateriallight
+      case "systemUltraThinMaterialDark":
+        self = .systemultrathinmaterialdark
+      case "systemThinMaterialDark":
+        self = .systemthinmaterialdark
+      case "systemMaterialDark":
+        self = .systemmaterialdark
+      case "systemThickMaterialDark":
+        self = .systemthickmaterialdark
+      case "systemChromeMaterialDark":
+        self = .systemchromematerialdark
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this BlurTint represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .light:
+        return "light"
+      case .dark:
+        return "dark"
+      case .default:
+        return "default"
+      case .extralight:
+        return "extraLight"
+      case .regular:
+        return "regular"
+      case .prominent:
+        return "prominent"
+      case .systemultrathinmaterial:
+        return "systemUltraThinMaterial"
+      case .systemthinmaterial:
+        return "systemThinMaterial"
+      case .systemmaterial:
+        return "systemMaterial"
+      case .systemthickmaterial:
+        return "systemThickMaterial"
+      case .systemchromematerial:
+        return "systemChromeMaterial"
+      case .systemultrathinmateriallight:
+        return "systemUltraThinMaterialLight"
+      case .systemthinmateriallight:
+        return "systemThinMaterialLight"
+      case .systemmateriallight:
+        return "systemMaterialLight"
+      case .systemthickmateriallight:
+        return "systemThickMaterialLight"
+      case .systemchromemateriallight:
+        return "systemChromeMaterialLight"
+      case .systemultrathinmaterialdark:
+        return "systemUltraThinMaterialDark"
+      case .systemthinmaterialdark:
+        return "systemThinMaterialDark"
+      case .systemmaterialdark:
+        return "systemMaterialDark"
+      case .systemthickmaterialdark:
+        return "systemThickMaterialDark"
+      case .systemchromematerialdark:
+        return "systemChromeMaterialDark"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/HybridNitroBlurSpec.swift

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