diff --git a/example/src/getTests.ts b/example/src/getTests.ts
index a9825a925..a2cdbbf8a 100644
--- a/example/src/getTests.ts
+++ b/example/src/getTests.ts
@@ -1732,6 +1732,26 @@ export function getTests(
         .didNotThrow()
         .equals(false)
     ),
+    createTest('areStructOfEnumsEqual(...) same struct', () =>
+      it(() =>
+        testObject.areStructOfEnumsEqual(
+          { powertrain: 'electric', oldEnum: OldEnum.FIRST },
+          { powertrain: 'electric', oldEnum: OldEnum.FIRST }
+        )
+      )
+        .didNotThrow()
+        .equals(true)
+    ),
+    createTest('areStructOfEnumsEqual(...) different structs', () =>
+      it(() =>
+        testObject.areStructOfEnumsEqual(
+          { powertrain: 'electric', oldEnum: OldEnum.FIRST },
+          { powertrain: 'gas', oldEnum: OldEnum.SECOND }
+        )
+      )
+        .didNotThrow()
+        .equals(false)
+    ),
     createTest('getDriver(...) with no driver', () =>
       it(() =>
         testObject.getDriver({
diff --git a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt
index 1471f72fa..a16e3fe8f 100644
--- a/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt
+++ b/packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt
@@ -441,6 +441,13 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
       a.someVariant == b.someVariant
   }
 
+  override fun areStructOfEnumsEqual(
+    left: StructOfEnums,
+    right: StructOfEnums,
+  ): Boolean {
+    return left == right
+  }
+
   override fun getDriver(car: Car): Person? {
     return car.driver
   }
diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp
index 28b89d252..ed623cce3 100644
--- a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp
+++ b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp
@@ -594,6 +594,10 @@ bool HybridTestObjectCpp::areCarsEqual(const Car& a, const Car& b) {
   return a == b;
 }
 
+bool HybridTestObjectCpp::areStructOfEnumsEqual(const StructOfEnums& left, const StructOfEnums& right) {
+  return left == right;
+}
+
 std::optional<Person> HybridTestObjectCpp::getDriver(const Car& car) {
   if (car.driver.has_value()) {
     return car.driver.value();
diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp
index 00231e96c..52b74d024 100644
--- a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp
+++ b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp
@@ -187,6 +187,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   Car getCar() override;
   bool isCarElectric(const Car& car) override;
   bool areCarsEqual(const Car& a, const Car& b) override;
+  bool areStructOfEnumsEqual(const StructOfEnums& left, const StructOfEnums& right) override;
   std::optional<Person> getDriver(const Car& car) override;
   Car bounceCar(const Car& car) override;
   void jsStyleObjectAsParameters(const JsStyleStruct& params) override;
diff --git a/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift b/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift
index d8ffcaa6d..47b9d2fd1 100644
--- a/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift
+++ b/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift
@@ -464,6 +464,10 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
     return a == b
   }
 
+  func areStructOfEnumsEqual(left: StructOfEnums, right: StructOfEnums) throws -> Bool {
+    return left == right
+  }
+
   func getDriver(car: Car) throws -> Person? {
     return car.driver
   }
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
index 779044251..ccffce1ad 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
@@ -41,6 +41,8 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; }
 namespace margelo::nitro::test { struct MapWrapper; }
 // Forward declaration of `SecondMapWrapper` to properly resolve imports.
 namespace margelo::nitro::test { struct SecondMapWrapper; }
+// Forward declaration of `StructOfEnums` to properly resolve imports.
+namespace margelo::nitro::test { struct StructOfEnums; }
 // Forward declaration of `HybridTestViewSpec` to properly resolve imports.
 namespace margelo::nitro::test { class HybridTestViewSpec; }
 
@@ -121,6 +123,8 @@ namespace margelo::nitro::test { class HybridTestViewSpec; }
 #include "JFunc_void_std__string.hpp"
 #include "JFunc_void_std__exception_ptr.hpp"
 #include "JFunc_std__shared_ptr_Promise_std__string__.hpp"
+#include "StructOfEnums.hpp"
+#include "JStructOfEnums.hpp"
 #include "JVariant_Boolean_DoubleArray_Array_String__String_Double.hpp"
 #include "JFunc_double.hpp"
 #include "HybridTestViewSpec.hpp"
@@ -1132,6 +1136,11 @@ namespace margelo::nitro::test {
     auto __result = method(_javaPart, JCar::fromCpp(a), JCar::fromCpp(b));
     return static_cast<bool>(__result);
   }
+  bool JHybridTestObjectSwiftKotlinSpec::areStructOfEnumsEqual(const StructOfEnums& left, const StructOfEnums& right) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<JStructOfEnums> /* left */, jni::alias_ref<JStructOfEnums> /* right */)>("areStructOfEnumsEqual");
+    auto __result = method(_javaPart, JStructOfEnums::fromCpp(left), JStructOfEnums::fromCpp(right));
+    return static_cast<bool>(__result);
+  }
   std::optional<Person> JHybridTestObjectSwiftKotlinSpec::getDriver(const Car& car) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPerson>(jni::alias_ref<JCar> /* car */)>("getDriver");
     auto __result = method(_javaPart, JCar::fromCpp(car));
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
index d821e23ae..52d3566c3 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
@@ -153,6 +153,7 @@ namespace margelo::nitro::test {
     Car getCar() override;
     bool isCarElectric(const Car& car) override;
     bool areCarsEqual(const Car& a, const Car& b) override;
+    bool areStructOfEnumsEqual(const StructOfEnums& left, const StructOfEnums& right) override;
     std::optional<Person> getDriver(const Car& car) override;
     Car bounceCar(const Car& car) override;
     void jsStyleObjectAsParameters(const JsStyleStruct& params) override;
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JStructOfEnums.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JStructOfEnums.hpp
new file mode 100644
index 000000000..a64ac5179
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JStructOfEnums.hpp
@@ -0,0 +1,64 @@
+///
+/// JStructOfEnums.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "StructOfEnums.hpp"
+
+#include "JOldEnum.hpp"
+#include "JPowertrain.hpp"
+#include "OldEnum.hpp"
+#include "Powertrain.hpp"
+
+namespace margelo::nitro::test {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "StructOfEnums" and the the Kotlin data class "StructOfEnums".
+   */
+  struct JStructOfEnums final: public jni::JavaClass<JStructOfEnums> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/StructOfEnums;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct StructOfEnums by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    StructOfEnums toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPowertrain = clazz->getField<JPowertrain>("powertrain");
+      jni::local_ref<JPowertrain> powertrain = this->getFieldValue(fieldPowertrain);
+      static const auto fieldOldEnum = clazz->getField<JOldEnum>("oldEnum");
+      jni::local_ref<JOldEnum> oldEnum = this->getFieldValue(fieldOldEnum);
+      return StructOfEnums(
+        powertrain->toCpp(),
+        oldEnum->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JStructOfEnums::javaobject> fromCpp(const StructOfEnums& value) {
+      using JSignature = JStructOfEnums(jni::alias_ref<JPowertrain>, jni::alias_ref<JOldEnum>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JPowertrain::fromCpp(value.powertrain),
+        JOldEnum::fromCpp(value.oldEnum)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt
index ae244266e..0d79c8fd7 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt
@@ -488,6 +488,10 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
   @Keep
   abstract fun areCarsEqual(a: Car, b: Car): Boolean
   
+  @DoNotStrip
+  @Keep
+  abstract fun areStructOfEnumsEqual(left: StructOfEnums, right: StructOfEnums): Boolean
+  
   @DoNotStrip
   @Keep
   abstract fun getDriver(car: Car): Person?
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/StructOfEnums.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/StructOfEnums.kt
new file mode 100644
index 000000000..bda361162
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/StructOfEnums.kt
@@ -0,0 +1,56 @@
+///
+/// StructOfEnums.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "StructOfEnums".
+ */
+@DoNotStrip
+@Keep
+data class StructOfEnums(
+  @DoNotStrip
+  @Keep
+  val powertrain: Powertrain,
+  @DoNotStrip
+  @Keep
+  val oldEnum: OldEnum
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is StructOfEnums) return false
+    return Objects.deepEquals(this.powertrain, other.powertrain)
+      && Objects.deepEquals(this.oldEnum, other.oldEnum)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf(
+      powertrain,
+      oldEnum
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(powertrain: Powertrain, oldEnum: OldEnum): StructOfEnums {
+      return StructOfEnums(powertrain, oldEnum)
+    }
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp
index 861fc58f4..a07ac3b98 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Umbrella.hpp
@@ -46,6 +46,8 @@ namespace margelo::nitro::test { struct Person; }
 namespace margelo::nitro::test { enum class Powertrain; }
 // Forward declaration of `SecondMapWrapper` to properly resolve imports.
 namespace margelo::nitro::test { struct SecondMapWrapper; }
+// Forward declaration of `StructOfEnums` to properly resolve imports.
+namespace margelo::nitro::test { struct StructOfEnums; }
 // Forward declaration of `WeirdNumbersEnum` to properly resolve imports.
 namespace margelo::nitro::test { enum class WeirdNumbersEnum; }
 // Forward declaration of `WrappedJsStruct` to properly resolve imports.
@@ -70,6 +72,7 @@ namespace margelo::nitro::test { struct WrappedJsStruct; }
 #include "Person.hpp"
 #include "Powertrain.hpp"
 #include "SecondMapWrapper.hpp"
+#include "StructOfEnums.hpp"
 #include "WeirdNumbersEnum.hpp"
 #include "WrappedJsStruct.hpp"
 #include <NitroModules/AnyMap.hpp>
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp
index 0acad0e77..15edd6b0b 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp
@@ -32,6 +32,8 @@ namespace NitroModules { class ArrayBufferHolder; }
 namespace margelo::nitro::test { struct MapWrapper; }
 // Forward declaration of `SecondMapWrapper` to properly resolve imports.
 namespace margelo::nitro::test { struct SecondMapWrapper; }
+// Forward declaration of `StructOfEnums` to properly resolve imports.
+namespace margelo::nitro::test { struct StructOfEnums; }
 // Forward declaration of `JsStyleStruct` to properly resolve imports.
 namespace margelo::nitro::test { struct JsStyleStruct; }
 // Forward declaration of `WrappedJsStruct` to properly resolve imports.
@@ -74,6 +76,7 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; }
 #include "SecondMapWrapper.hpp"
 #include <exception>
 #include <chrono>
+#include "StructOfEnums.hpp"
 #include "JsStyleStruct.hpp"
 #include "WrappedJsStruct.hpp"
 #include "OptionalWrapper.hpp"
@@ -742,6 +745,14 @@ namespace margelo::nitro::test {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline bool areStructOfEnumsEqual(const StructOfEnums& left, const StructOfEnums& right) override {
+      auto __result = _swiftPart.areStructOfEnumsEqual(std::forward<decltype(left)>(left), std::forward<decltype(right)>(right));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::optional<Person> getDriver(const Car& car) override {
       auto __result = _swiftPart.getDriver(std::forward<decltype(car)>(car));
       if (__result.hasError()) [[unlikely]] {
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift
index b7c50eb1a..20669245e 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift
@@ -96,6 +96,7 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: HybridObject {
   func getCar() throws -> Car
   func isCarElectric(car: Car) throws -> Bool
   func areCarsEqual(a: Car, b: Car) throws -> Bool
+  func areStructOfEnumsEqual(left: StructOfEnums, right: StructOfEnums) throws -> Bool
   func getDriver(car: Car) throws -> Person?
   func bounceCar(car: Car) throws -> Car
   func jsStyleObjectAsParameters(params: JsStyleStruct) throws -> Void
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift
index 1b90ccf62..cadc4cf09 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift
@@ -1861,6 +1861,18 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func areStructOfEnumsEqual(left: StructOfEnums, right: StructOfEnums) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.areStructOfEnumsEqual(left: left, right: right)
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func getDriver(car: Car) -> bridge.Result_std__optional_Person__ {
     do {
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/StructOfEnums.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/StructOfEnums.swift
new file mode 100644
index 000000000..3ac882f75
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/StructOfEnums.swift
@@ -0,0 +1,34 @@
+///
+/// StructOfEnums.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 `StructOfEnums`, backed by a C++ struct.
+ */
+public typealias StructOfEnums = margelo.nitro.test.StructOfEnums
+
+public extension StructOfEnums {
+  private typealias bridge = margelo.nitro.test.bridge.swift
+
+  /**
+   * Create a new instance of `StructOfEnums`.
+   */
+  init(powertrain: Powertrain, oldEnum: OldEnum) {
+    self.init(powertrain, oldEnum)
+  }
+
+  @inline(__always)
+  var powertrain: Powertrain {
+    return self.__powertrain
+  }
+  
+  @inline(__always)
+  var oldEnum: OldEnum {
+    return self.__oldEnum
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp
index 663611723..0bdb7fbab 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp
@@ -121,6 +121,7 @@ namespace margelo::nitro::test {
       prototype.registerHybridMethod("getCar", &HybridTestObjectCppSpec::getCar);
       prototype.registerHybridMethod("isCarElectric", &HybridTestObjectCppSpec::isCarElectric);
       prototype.registerHybridMethod("areCarsEqual", &HybridTestObjectCppSpec::areCarsEqual);
+      prototype.registerHybridMethod("areStructOfEnumsEqual", &HybridTestObjectCppSpec::areStructOfEnumsEqual);
       prototype.registerHybridMethod("getDriver", &HybridTestObjectCppSpec::getDriver);
       prototype.registerHybridMethod("bounceCar", &HybridTestObjectCppSpec::bounceCar);
       prototype.registerHybridMethod("jsStyleObjectAsParameters", &HybridTestObjectCppSpec::jsStyleObjectAsParameters);
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp
index ad65490e1..96c259a11 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp
@@ -31,6 +31,8 @@ namespace margelo::nitro::test { struct Car; }
 namespace margelo::nitro::test { class HybridChildSpec; }
 // Forward declaration of `MapWrapper` to properly resolve imports.
 namespace margelo::nitro::test { struct MapWrapper; }
+// Forward declaration of `StructOfEnums` to properly resolve imports.
+namespace margelo::nitro::test { struct StructOfEnums; }
 // Forward declaration of `JsStyleStruct` to properly resolve imports.
 namespace margelo::nitro::test { struct JsStyleStruct; }
 // Forward declaration of `WrappedJsStruct` to properly resolve imports.
@@ -74,6 +76,7 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; }
 #include "MapWrapper.hpp"
 #include <exception>
 #include <chrono>
+#include "StructOfEnums.hpp"
 #include "JsStyleStruct.hpp"
 #include "WrappedJsStruct.hpp"
 #include "OptionalWrapper.hpp"
@@ -221,6 +224,7 @@ namespace margelo::nitro::test {
       virtual Car getCar() = 0;
       virtual bool isCarElectric(const Car& car) = 0;
       virtual bool areCarsEqual(const Car& a, const Car& b) = 0;
+      virtual bool areStructOfEnumsEqual(const StructOfEnums& left, const StructOfEnums& right) = 0;
       virtual std::optional<Person> getDriver(const Car& car) = 0;
       virtual Car bounceCar(const Car& car) = 0;
       virtual void jsStyleObjectAsParameters(const JsStyleStruct& params) = 0;
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp
index 862ca6145..084ba9ae7 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp
@@ -114,6 +114,7 @@ namespace margelo::nitro::test {
       prototype.registerHybridMethod("getCar", &HybridTestObjectSwiftKotlinSpec::getCar);
       prototype.registerHybridMethod("isCarElectric", &HybridTestObjectSwiftKotlinSpec::isCarElectric);
       prototype.registerHybridMethod("areCarsEqual", &HybridTestObjectSwiftKotlinSpec::areCarsEqual);
+      prototype.registerHybridMethod("areStructOfEnumsEqual", &HybridTestObjectSwiftKotlinSpec::areStructOfEnumsEqual);
       prototype.registerHybridMethod("getDriver", &HybridTestObjectSwiftKotlinSpec::getDriver);
       prototype.registerHybridMethod("bounceCar", &HybridTestObjectSwiftKotlinSpec::bounceCar);
       prototype.registerHybridMethod("jsStyleObjectAsParameters", &HybridTestObjectSwiftKotlinSpec::jsStyleObjectAsParameters);
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp
index 96e5cb96b..ae8eb14da 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp
@@ -29,6 +29,8 @@ namespace margelo::nitro::test { struct Car; }
 namespace margelo::nitro::test { class HybridChildSpec; }
 // Forward declaration of `MapWrapper` to properly resolve imports.
 namespace margelo::nitro::test { struct MapWrapper; }
+// Forward declaration of `StructOfEnums` to properly resolve imports.
+namespace margelo::nitro::test { struct StructOfEnums; }
 // Forward declaration of `JsStyleStruct` to properly resolve imports.
 namespace margelo::nitro::test { struct JsStyleStruct; }
 // Forward declaration of `WrappedJsStruct` to properly resolve imports.
@@ -69,6 +71,7 @@ namespace margelo::nitro::test { struct ExternalObjectStruct; }
 #include "MapWrapper.hpp"
 #include <exception>
 #include <chrono>
+#include "StructOfEnums.hpp"
 #include "JsStyleStruct.hpp"
 #include "WrappedJsStruct.hpp"
 #include "OptionalWrapper.hpp"
@@ -209,6 +212,7 @@ namespace margelo::nitro::test {
       virtual Car getCar() = 0;
       virtual bool isCarElectric(const Car& car) = 0;
       virtual bool areCarsEqual(const Car& a, const Car& b) = 0;
+      virtual bool areStructOfEnumsEqual(const StructOfEnums& left, const StructOfEnums& right) = 0;
       virtual std::optional<Person> getDriver(const Car& car) = 0;
       virtual Car bounceCar(const Car& car) = 0;
       virtual void jsStyleObjectAsParameters(const JsStyleStruct& params) = 0;
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/StructOfEnums.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/StructOfEnums.hpp
new file mode 100644
index 000000000..94dfda73c
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/StructOfEnums.hpp
@@ -0,0 +1,91 @@
+///
+/// StructOfEnums.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/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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `Powertrain` to properly resolve imports.
+namespace margelo::nitro::test { enum class Powertrain; }
+// Forward declaration of `OldEnum` to properly resolve imports.
+namespace margelo::nitro::test { enum class OldEnum; }
+
+#include "Powertrain.hpp"
+#include "OldEnum.hpp"
+
+namespace margelo::nitro::test {
+
+  /**
+   * A struct which can be represented as a JavaScript object (StructOfEnums).
+   */
+  struct StructOfEnums final {
+  public:
+    Powertrain powertrain     SWIFT_PRIVATE;
+    OldEnum oldEnum     SWIFT_PRIVATE;
+
+  public:
+    StructOfEnums() = default;
+    explicit StructOfEnums(Powertrain powertrain, OldEnum oldEnum): powertrain(powertrain), oldEnum(oldEnum) {}
+
+  public:
+    friend bool operator==(const StructOfEnums& lhs, const StructOfEnums& rhs) = default;
+  };
+
+} // namespace margelo::nitro::test
+
+namespace margelo::nitro {
+
+  // C++ StructOfEnums <> JS StructOfEnums (object)
+  template <>
+  struct JSIConverter<margelo::nitro::test::StructOfEnums> final {
+    static inline margelo::nitro::test::StructOfEnums fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::test::StructOfEnums(
+        JSIConverter<margelo::nitro::test::Powertrain>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "powertrain"))),
+        JSIConverter<margelo::nitro::test::OldEnum>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "oldEnum")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::test::StructOfEnums& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "powertrain"), JSIConverter<margelo::nitro::test::Powertrain>::toJSI(runtime, arg.powertrain));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "oldEnum"), JSIConverter<margelo::nitro::test::OldEnum>::toJSI(runtime, arg.oldEnum));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<margelo::nitro::test::Powertrain>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "powertrain")))) return false;
+      if (!JSIConverter<margelo::nitro::test::OldEnum>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "oldEnum")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
diff --git a/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts
index 9b9db691f..f000f9f75 100644
--- a/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts
+++ b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts
@@ -40,6 +40,13 @@ export enum WeirdNumbersEnum {
   C = 64,
 }
 
+// A struct that contains enums, which are often tricky to bridge.
+// This explicitly tests if this struct of enums is equatable in Swift.
+export interface StructOfEnums {
+  powertrain: Powertrain
+  oldEnum: OldEnum
+}
+
 // A plain interface that does not inherit from `HybridObject` becomes a `struct` in C++.
 // They can only have properties (get + set). No methods or native state.
 export interface Car {
@@ -126,7 +133,7 @@ interface SharedTestObjectProps {
   optionalOldEnum?: OldEnum
   optionalCallback?: (value: number) => void
 
-  // Kotlin/Swift simplify boolean names (has*/is*)
+  // Test Kotlin/Swift simplify boolean names (has*/is*)
   readonly hasBoolean: boolean
   readonly isBoolean: boolean
   hasBooleanWritable: boolean
@@ -242,6 +249,7 @@ interface SharedTestObjectProps {
   getCar(): Car
   isCarElectric(car: Car): boolean
   areCarsEqual(a: Car, b: Car): boolean
+  areStructOfEnumsEqual(left: StructOfEnums, right: StructOfEnums): boolean
   getDriver(car: Car): Person | undefined
   bounceCar(car: Car): Car
   jsStyleObjectAsParameters(params: JsStyleStruct): void