diff --git a/packages/nitrogen/src/syntax/kotlin/KotlinStruct.ts b/packages/nitrogen/src/syntax/kotlin/KotlinStruct.ts
index 6db1913d51..27cb4cb565 100644
--- a/packages/nitrogen/src/syntax/kotlin/KotlinStruct.ts
+++ b/packages/nitrogen/src/syntax/kotlin/KotlinStruct.ts
@@ -128,12 +128,14 @@ data class ${structType.structName}(
     const returnType = property.getCode('c++', { context: 'return' })
     const signatureType = getJniCode(property, { context: 'property' })
     const name = capitalizeName(property.escapedName)
-    const methodResult = convertJniValue(property, 'method(this->self())', 'from-jni')
+    const methodResult = convertJniValue(property, 'method(this->self(), clazz)', 'from-jni')
     const fieldResult = convertJniValue(property, 'getFieldValue(field)', 'from-jni')
     if (!property.isKotlinFieldCompatible) {
+      // The getter is private and final, so JNI calls it without a virtual lookup.
       return `
 ${returnType} get${name}() const {
-  static const auto method = javaClassStatic()->getMethod<${signatureType}()>("get${name}_cxx");
+  static const auto clazz = javaClassStatic();
+  static const auto method = clazz->getNonvirtualMethod<${signatureType}()>("get${name}_cxx");
   return ${methodResult};
 }
 `.trim()
diff --git a/packages/nitrogen/src/syntax/kotlin/KotlinVariant.ts b/packages/nitrogen/src/syntax/kotlin/KotlinVariant.ts
index e634ca9d42..cdaab07c6a 100644
--- a/packages/nitrogen/src/syntax/kotlin/KotlinVariant.ts
+++ b/packages/nitrogen/src/syntax/kotlin/KotlinVariant.ts
@@ -14,13 +14,27 @@ export function createKotlinVariant(variant: KotlinVariantType): SourceFile[] {
   const kotlinName = variant.name
   const namespace = `${jniName}_impl`
 
-  const innerClasses = variant.kotlinCases.map(({ label, type }, index) => {
+  const innerClasses = variant.kotlinCases.map(({ label, publicType, type }, index) => {
     const innerName = capitalizeName(label)
-    const valueType = type.getCode('kotlin', { context: 'property' })
-    return `
+    const valueType = publicType.getCode('kotlin', { context: 'property' })
+    const classCode = `
 @DoNotStrip
 data class ${innerName}(@DoNotStrip val value: ${valueType}): ${kotlinName}(${index})
-      `.trim()
+`.trim()
+    const isFieldCompatible = type.isKotlinFieldCompatible ?? !type.needsKotlinConversion
+    if (isFieldCompatible) return classCode
+    // JNI reads values that Kotlin represents differently, e.g. `Long` for `ULong`, through an accessor.
+    const bridgeType = type.getCode('kotlin', { context: 'return' })
+    const bridgeValue = type.convert('value', { from: 'kotlin', to: 'c++', in: 'kotlin' })
+    return `
+${classCode} {
+  @DoNotStrip
+  @Suppress("unused", "FunctionName")
+  private fun getValue_cxx(): ${bridgeType} {
+    return ${bridgeValue}
+  }
+}
+`.trim()
   })
 
   const packageName = config.getAndroidPackage('java/kotlin')
@@ -31,19 +45,14 @@ val is${innerName}: Boolean
   get() = this is ${innerName}
     `.trim()
   })
-  const asFunctions = variant.kotlinCases.map(({ label, publicType, type }) => {
+  const asFunctions = variant.kotlinCases.map(({ label, publicType }) => {
     const innerName = capitalizeName(label)
     const optional = new OptionalType(publicType)
     const optionalType = optional.getCode('kotlin', { context: 'return' })
-    const publicValue = type.convert('value', {
-      from: 'c++',
-      to: 'kotlin',
-      in: 'kotlin',
-    })
     return `
 fun as${innerName}OrNull(): ${optionalType} {
   val value = (this as? ${innerName})?.value ?: return null
-  return ${publicValue}
+  return value
 }
     `.trim()
   })
@@ -51,26 +60,16 @@ fun as${innerName}OrNull(): ${optionalType} {
     const type = publicType.getCode('kotlin', { context: 'parameter' })
     return `${label}: (${type}) -> R`
   })
-  const matchCases = variant.kotlinCases.map(({ label, type }) => {
+  const matchCases = variant.kotlinCases.map(({ label }) => {
     const innerName = capitalizeName(label)
-    const publicValue = type.convert('value', {
-      from: 'c++',
-      to: 'kotlin',
-      in: 'kotlin',
-    })
     return `
-is ${innerName} -> ${label}(${publicValue})
+is ${innerName} -> ${label}(value)
     `.trim()
   })
-  const asCases = variant.kotlinCases.map(({ label, type }) => {
+  const asCases = variant.kotlinCases.map(({ label }) => {
     const innerName = capitalizeName(label)
-    const publicValue = type.convert('value', {
-      from: 'c++',
-      to: 'kotlin',
-      in: 'kotlin',
-    })
     return `
-is ${innerName} -> (${publicValue}) as? T
+is ${innerName} -> (value) as? T
     `.trim()
   })
 
@@ -78,9 +77,9 @@ is ${innerName} -> (${publicValue}) as? T
     const innerName = capitalizeName(label)
     const valueType = publicType.getCode('kotlin', { context: 'parameter' })
     const bridgeType = type.getCode('kotlin', { context: 'parameter' })
-    const bridgeValue = type.convert('value', {
-      from: 'kotlin',
-      to: 'c++',
+    const publicValue = type.convert('value', {
+      from: 'c++',
+      to: 'kotlin',
       in: 'kotlin',
     })
     // Cases such as two callbacks can erase to the same JVM type, so give each a JVM name.
@@ -88,11 +87,11 @@ is ${innerName} -> (${publicValue}) as? T
 @JvmStatic
 @JvmName("create${innerName}")
 @DoNotStrip
-fun create(value: ${valueType}): ${kotlinName} = ${innerName}(${bridgeValue})
+fun create(value: ${valueType}): ${kotlinName} = ${innerName}(value)
 
 @JvmStatic
 @DoNotStrip
-private fun fromCpp_${i}(value: ${bridgeType}): ${kotlinName} = ${innerName}(value)
+private fun fromCpp_${i}(value: ${bridgeType}): ${kotlinName} = ${innerName}(${publicValue})
 `.trim()
   })
 
@@ -150,7 +149,23 @@ sealed class ${kotlinName} private constructor(@DoNotStrip private val index: In
     const valueType = type.getCode('c++', { context: 'return' })
     const parameterType = type.getCode('c++', { context: 'parameter' })
     const createValue = convertJniValue(type, 'value', 'to-jni')
-    const extractedValue = convertJniValue(type, 'getFieldValue(field)', 'from-jni')
+    const isFieldCompatible = type.isKotlinFieldCompatible ?? !type.needsKotlinConversion
+    let getValueBody: string
+    if (isFieldCompatible) {
+      const extractedValue = convertJniValue(type, 'getFieldValue(field)', 'from-jni')
+      getValueBody = `
+static const auto field = javaClassStatic()->getField<${jniField}>("value");
+return ${extractedValue};
+`.trim()
+    } else {
+      // The accessor is private and final, so JNI calls it without a virtual lookup.
+      const extractedValue = convertJniValue(type, 'method(self(), clazz)', 'from-jni')
+      getValueBody = `
+static const auto clazz = javaClassStatic();
+static const auto method = clazz->getNonvirtualMethod<${jniField}()>("getValue_cxx");
+return ${extractedValue};
+`.trim()
+    }
     const declaration = `
 class ${innerName} final : public jni::JavaClass<${innerName}, ${jniName}> {
 public:
@@ -168,8 +183,7 @@ jni::local_ref<${jniName}> ${namespace}::${innerName}::create(${parameterType} v
 }
 
 ${namespace}::${innerName}::Value ${namespace}::${innerName}::getValue() const {
-  static const auto field = javaClassStatic()->getField<${jniField}>("value");
-  return ${extractedValue};
+  ${indent(getValueBody, '  ')}
 }
 `.trim()
     return { name: innerName, declaration: declaration, implementation: implementation }
diff --git a/tests/standalone/nitro-test-external/nitrogen/generated/android/c++/include/NitroTestExternal/private/JOptionalPrimitivesHolder.hpp b/tests/standalone/nitro-test-external/nitrogen/generated/android/c++/include/NitroTestExternal/private/JOptionalPrimitivesHolder.hpp
index fa1e76c9c5..9200e1f509 100644
--- a/tests/standalone/nitro-test-external/nitrogen/generated/android/c++/include/NitroTestExternal/private/JOptionalPrimitivesHolder.hpp
+++ b/tests/standalone/nitro-test-external/nitrogen/generated/android/c++/include/NitroTestExternal/private/JOptionalPrimitivesHolder.hpp
@@ -40,8 +40,9 @@ namespace margelo::nitro::test::external {
     }
 
     jni::local_ref<JOptional<JUInt64>> getOptionalUInt64() const {
-      static const auto method = javaClassStatic()->getMethod<JOptional<JUInt64>()>("getOptionalUInt64_cxx");
-      return method(this->self());
+      static const auto clazz = javaClassStatic();
+      static const auto method = clazz->getNonvirtualMethod<JOptional<JUInt64>()>("getOptionalUInt64_cxx");
+      return method(this->self(), clazz);
     }
 
     jni::local_ref<JOptional<jni::JLong>> getOptionalInt64() const {
diff --git a/tests/standalone/nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt b/tests/standalone/nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt
index d7ca858023..dfc8a55cc1 100644
--- a/tests/standalone/nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt
+++ b/tests/standalone/nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt
@@ -226,6 +226,21 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
     return callback.callSync(array)
   }
 
+  override fun bounceUnsignedVariant(variant: Variant_ULong_String): Variant_ULong_String {
+    // Rebuild the case so it goes through the public ULong constructor.
+    return when (variant) {
+      is Variant_ULong_String.First -> Variant_ULong_String.First(variant.value)
+      is Variant_ULong_String.Second -> Variant_ULong_String.Second(variant.value)
+    }
+  }
+
+  override fun bounceUnsignedArrayVariant(variant: Variant_ULongArray_String): Variant_ULongArray_String {
+    return variant.match(
+      { array -> Variant_ULongArray_String.create(array) },
+      { string -> Variant_ULongArray_String.create(string) },
+    )
+  }
+
   override fun bounceHybridObjects(array: Array<HybridChildSpec>): Array<HybridChildSpec> {
     return array
   }
diff --git a/tests/standalone/nitro-test/apple/HybridTestObjectSwift.swift b/tests/standalone/nitro-test/apple/HybridTestObjectSwift.swift
index 03abaaaef2..0be738f8bf 100644
--- a/tests/standalone/nitro-test/apple/HybridTestObjectSwift.swift
+++ b/tests/standalone/nitro-test/apple/HybridTestObjectSwift.swift
@@ -387,6 +387,14 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
     return try callback.callSync(array)
   }
 
+  func bounceUnsignedVariant(variant: Variant_UInt64_String) throws -> Variant_UInt64_String {
+    return variant
+  }
+
+  func bounceUnsignedArrayVariant(variant: Variant__UInt64__String) throws -> Variant__UInt64__String {
+    return variant
+  }
+
   func bounceHybridObjects(array: [(any HybridChildSpec)]) throws -> [(any HybridChildSpec)] {
     return array
   }
diff --git a/tests/standalone/nitro-test/cpp/HybridTestObjectCpp.cpp b/tests/standalone/nitro-test/cpp/HybridTestObjectCpp.cpp
index 26e26e1938..ced78d6e75 100644
--- a/tests/standalone/nitro-test/cpp/HybridTestObjectCpp.cpp
+++ b/tests/standalone/nitro-test/cpp/HybridTestObjectCpp.cpp
@@ -382,6 +382,15 @@ HybridTestObjectCpp::callUnsignedArrayCallback(const std::vector<uint64_t>& arra
   return callback.callSync(array);
 }
 
+std::variant<uint64_t, std::string> HybridTestObjectCpp::bounceUnsignedVariant(const std::variant<uint64_t, std::string>& variant) {
+  return variant;
+}
+
+std::variant<std::vector<uint64_t>, std::string>
+HybridTestObjectCpp::bounceUnsignedArrayVariant(const std::variant<std::vector<uint64_t>, std::string>& variant) {
+  return variant;
+}
+
 std::vector<HybridChildSpecCxx> HybridTestObjectCpp::bounceHybridObjects(const std::vector<HybridChildSpecCxx>& array) {
   return array;
 }
diff --git a/tests/standalone/nitro-test/cpp/HybridTestObjectCpp.hpp b/tests/standalone/nitro-test/cpp/HybridTestObjectCpp.hpp
index c4816cf6fd..75223ee623 100644
--- a/tests/standalone/nitro-test/cpp/HybridTestObjectCpp.hpp
+++ b/tests/standalone/nitro-test/cpp/HybridTestObjectCpp.hpp
@@ -185,6 +185,9 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   Promise<std::vector<uint64_t>> bounceUnsignedArrayAsync(const std::vector<uint64_t>& array) override;
   std::vector<uint64_t> callUnsignedArrayCallback(const std::vector<uint64_t>& array,
                                                   const Callback<std::vector<uint64_t>(const std::vector<uint64_t>&)>& callback) override;
+  std::variant<uint64_t, std::string> bounceUnsignedVariant(const std::variant<uint64_t, std::string>& variant) override;
+  std::variant<std::vector<uint64_t>, std::string>
+  bounceUnsignedArrayVariant(const std::variant<std::vector<uint64_t>, std::string>& variant) override;
 
   std::vector<HybridChildSpecCxx> bounceHybridObjects(const std::vector<HybridChildSpecCxx>& array) override;
   std::vector<Callback<void()>> bounceFunctions(const std::vector<Callback<void()>>& functions) override;
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake b/tests/standalone/nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake
index 322a4ed0b7..968744d788 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake
@@ -88,6 +88,8 @@ target_sources(NitroTest PRIVATE
   "${CMAKE_CURRENT_LIST_DIR}/../android/c++/JVariant_OldEnum_Boolean.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/../android/c++/JVariant_Person_Car.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/../android/c++/JVariant_Powertrain_Car.cpp"
+  "${CMAKE_CURRENT_LIST_DIR}/../android/c++/JVariant_ULongArray_String.cpp"
+  "${CMAKE_CURRENT_LIST_DIR}/../android/c++/JVariant_ULong_String.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/../android/c++/JVariant_WeirdNumbersEnum_Boolean.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/../android/c++/JWeirdNumbersEnum.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/../android/c++/JWrappedJsStruct.cpp"
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/HybridTestObjectCppSpecClass.cpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/HybridTestObjectCppSpecClass.cpp
index 240c373dea..076cde2198 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/c++/HybridTestObjectCppSpecClass.cpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/HybridTestObjectCppSpecClass.cpp
@@ -152,6 +152,8 @@ namespace margelo::nitro::test {
       clazz.registerHybridMethod("bounceOptionalUnsignedArray", &HybridTestObjectCppSpec::bounceOptionalUnsignedArray);
       clazz.registerHybridMethod("bounceUnsignedArrayAsync", &HybridTestObjectCppSpec::bounceUnsignedArrayAsync);
       clazz.registerHybridMethod("callUnsignedArrayCallback", &HybridTestObjectCppSpec::callUnsignedArrayCallback);
+      clazz.registerHybridMethod("bounceUnsignedVariant", &HybridTestObjectCppSpec::bounceUnsignedVariant);
+      clazz.registerHybridMethod("bounceUnsignedArrayVariant", &HybridTestObjectCppSpec::bounceUnsignedArrayVariant);
       clazz.registerHybridMethod("bounceHybridObjects", &HybridTestObjectCppSpec::bounceHybridObjects);
       clazz.registerHybridMethod("bounceFunctions", &HybridTestObjectCppSpec::bounceFunctions);
       clazz.registerHybridMethod("bounceMaps", &HybridTestObjectCppSpec::bounceMaps);
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/JCoreTypesVariant.cpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/JCoreTypesVariant.cpp
index 7f40ddd4af..a2025a3088 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/c++/JCoreTypesVariant.cpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/JCoreTypesVariant.cpp
@@ -44,8 +44,9 @@ namespace margelo::nitro::test {
   }
 
   JCoreTypesVariant_impl::Second::Value JCoreTypesVariant_impl::Second::getValue() const {
-    static const auto field = javaClassStatic()->getField<margelo::nitro::test::JCallback_void_double::JavaPart>("value");
-    return getFieldValue(field);
+    static const auto clazz = javaClassStatic();
+    static const auto method = clazz->getNonvirtualMethod<margelo::nitro::test::JCallback_void_double::JavaPart()>("getValue_cxx");
+    return method(self(), clazz);
   }
 
   jni::local_ref<JCoreTypesVariant> JCoreTypesVariant_impl::Third::create(jni::alias_ref<JWrappedJsStruct> value) {
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
index 45022a90e3..7e61b781b9 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
@@ -32,6 +32,8 @@
 #include <NitroTest/private/JCallback_std__vector_Powertrain__std__vector_Powertrain_.hpp>
 #include <NitroModules/JNIConverter+Promise.hpp>
 #include <NitroModules/JSIConverter+JTypedPromise.hpp>
+#include <NitroTest/private/JVariant_ULong_String.hpp>
+#include <NitroTest/private/JVariant_ULongArray_String.hpp>
 #include <NitroTest/private/JHybridChildSpec.hpp>
 #include <NitroTest/private/JCallback_void.hpp>
 #include <NitroModules/AnyJSON.hpp>
@@ -198,6 +200,8 @@ namespace margelo::nitro::test {
       clazz.registerHybridMethod("bounceOptionalUnsignedArray", &JHybridTestObjectSwiftKotlinSpec::bounceOptionalUnsignedArray);
       clazz.registerHybridMethod("bounceUnsignedArrayAsync", &JHybridTestObjectSwiftKotlinSpec::bounceUnsignedArrayAsync);
       clazz.registerHybridMethod("callUnsignedArrayCallback", &JHybridTestObjectSwiftKotlinSpec::callUnsignedArrayCallback);
+      clazz.registerHybridMethod("bounceUnsignedVariant", &JHybridTestObjectSwiftKotlinSpec::bounceUnsignedVariant);
+      clazz.registerHybridMethod("bounceUnsignedArrayVariant", &JHybridTestObjectSwiftKotlinSpec::bounceUnsignedArrayVariant);
       clazz.registerHybridMethod("bounceHybridObjects", &JHybridTestObjectSwiftKotlinSpec::bounceHybridObjects);
       clazz.registerHybridMethod("bounceFunctions", &JHybridTestObjectSwiftKotlinSpec::bounceFunctions);
       clazz.registerHybridMethod("bounceMaps", &JHybridTestObjectSwiftKotlinSpec::bounceMaps);
@@ -679,6 +683,16 @@ namespace margelo::nitro::test {
     auto __result = __method(_javaPart, CxxPart::getClass(), array, callback);
     return __result;
   }
+  jni::local_ref<JVariant_ULong_String> JHybridTestObjectSwiftKotlinSpec::bounceUnsignedVariant(const jni::local_ref<JVariant_ULong_String>& variant) {
+    static const auto __method = CxxPart::getClass()->getNonvirtualMethod<jni::local_ref<JVariant_ULong_String>(jni::alias_ref<JVariant_ULong_String> /* variant */)>("bounceUnsignedVariant");
+    auto __result = __method(_javaPart, CxxPart::getClass(), variant);
+    return __result;
+  }
+  jni::local_ref<JVariant_ULongArray_String> JHybridTestObjectSwiftKotlinSpec::bounceUnsignedArrayVariant(const jni::local_ref<JVariant_ULongArray_String>& variant) {
+    static const auto __method = CxxPart::getClass()->getNonvirtualMethod<jni::local_ref<JVariant_ULongArray_String>(jni::alias_ref<JVariant_ULongArray_String> /* variant */)>("bounceUnsignedArrayVariant");
+    auto __result = __method(_javaPart, CxxPart::getClass(), variant);
+    return __result;
+  }
   jni::local_ref<jni::JArrayClass<JHybridChildSpecJavaPart>> JHybridTestObjectSwiftKotlinSpec::bounceHybridObjects(const jni::local_ref<jni::JArrayClass<JHybridChildSpecJavaPart>>& array) {
     static const auto __method = CxxPart::getClass()->getNonvirtualMethod<jni::local_ref<jni::JArrayClass<JHybridChildSpecJavaPart>>(jni::alias_ref<jni::JArrayClass<JHybridChildSpecJavaPart>> /* array */)>("bounceHybridObjects");
     auto __result = __method(_javaPart, CxxPart::getClass(), array);
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/JVariant_Callback_______Unit__Double.cpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/JVariant_Callback_______Unit__Double.cpp
index 96bc91ff2c..a181a9f21a 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/c++/JVariant_Callback_______Unit__Double.cpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/JVariant_Callback_______Unit__Double.cpp
@@ -24,8 +24,9 @@ namespace margelo::nitro::test {
   }
 
   JVariant_Callback_______Unit__Double_impl::First::Value JVariant_Callback_______Unit__Double_impl::First::getValue() const {
-    static const auto field = javaClassStatic()->getField<margelo::nitro::test::JCallback_void::JavaPart>("value");
-    return getFieldValue(field);
+    static const auto clazz = javaClassStatic();
+    static const auto method = clazz->getNonvirtualMethod<margelo::nitro::test::JCallback_void::JavaPart()>("getValue_cxx");
+    return method(self(), clazz);
   }
 
   jni::local_ref<JVariant_Callback_______Unit__Double> JVariant_Callback_______Unit__Double_impl::Second::create(jdouble value) {
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/JVariant_ULongArray_String.cpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/JVariant_ULongArray_String.cpp
new file mode 100644
index 0000000000..0327689a0c
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/JVariant_ULongArray_String.cpp
@@ -0,0 +1,43 @@
+///
+/// JVariant_ULongArray_String.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <NitroTest/private/JVariant_ULongArray_String.hpp>
+#include <NitroModules/JNIConverter+Primitives.hpp>
+#include <NitroModules/JSIConverter+JNIPrimitives.hpp>
+#include <NitroModules/JNIConverter+Array.hpp>
+#include <NitroModules/JSIConverter+JPrimitiveArray.hpp>
+#include <NitroModules/JNIConverter+String.hpp>
+#include <NitroModules/JSIConverter+JString.hpp>
+
+namespace margelo::nitro::test {
+
+  size_t JVariant_ULongArray_String::getIndex() const {
+    static const auto field = javaClassStatic()->getField<jint>("index");
+    return static_cast<size_t>(getFieldValue(field));
+  }
+
+  jni::local_ref<JVariant_ULongArray_String> JVariant_ULongArray_String_impl::First::create(jni::alias_ref<JArrayUInt64> value) {
+    static const auto method = JVariant_ULongArray_String::javaClassStatic()->getStaticMethod<jni::local_ref<JVariant_ULongArray_String>(jni::alias_ref<JArrayUInt64>)>("fromCpp_0");
+    return method(JVariant_ULongArray_String::javaClassStatic(), value);
+  }
+
+  JVariant_ULongArray_String_impl::First::Value JVariant_ULongArray_String_impl::First::getValue() const {
+    static const auto field = javaClassStatic()->getField<JArrayUInt64>("value");
+    return getFieldValue(field);
+  }
+
+  jni::local_ref<JVariant_ULongArray_String> JVariant_ULongArray_String_impl::Second::create(jni::alias_ref<jni::JString> value) {
+    static const auto method = JVariant_ULongArray_String::javaClassStatic()->getStaticMethod<jni::local_ref<JVariant_ULongArray_String>(jni::alias_ref<jni::JString>)>("fromCpp_1");
+    return method(JVariant_ULongArray_String::javaClassStatic(), value);
+  }
+
+  JVariant_ULongArray_String_impl::Second::Value JVariant_ULongArray_String_impl::Second::getValue() const {
+    static const auto field = javaClassStatic()->getField<jni::JString>("value");
+    return getFieldValue(field);
+  }
+
+} // namespace margelo::nitro::test
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/JVariant_ULong_String.cpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/JVariant_ULong_String.cpp
new file mode 100644
index 0000000000..ff9a2b9ea9
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/JVariant_ULong_String.cpp
@@ -0,0 +1,41 @@
+///
+/// JVariant_ULong_String.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <NitroTest/private/JVariant_ULong_String.hpp>
+#include <NitroModules/JNIConverter+Primitives.hpp>
+#include <NitroModules/JSIConverter+JNIPrimitives.hpp>
+#include <NitroModules/JNIConverter+String.hpp>
+#include <NitroModules/JSIConverter+JString.hpp>
+
+namespace margelo::nitro::test {
+
+  size_t JVariant_ULong_String::getIndex() const {
+    static const auto field = javaClassStatic()->getField<jint>("index");
+    return static_cast<size_t>(getFieldValue(field));
+  }
+
+  jni::local_ref<JVariant_ULong_String> JVariant_ULong_String_impl::First::create(uint64_t value) {
+    static const auto method = JVariant_ULong_String::javaClassStatic()->getStaticMethod<jni::local_ref<JVariant_ULong_String>(jlong)>("fromCpp_0");
+    return method(JVariant_ULong_String::javaClassStatic(), JNIConverter<uint64_t, jlong>::toJNI(value));
+  }
+
+  JVariant_ULong_String_impl::First::Value JVariant_ULong_String_impl::First::getValue() const {
+    static const auto field = javaClassStatic()->getField<jlong>("value");
+    return JNIConverter<uint64_t, jlong>::fromJNI(getFieldValue(field));
+  }
+
+  jni::local_ref<JVariant_ULong_String> JVariant_ULong_String_impl::Second::create(jni::alias_ref<jni::JString> value) {
+    static const auto method = JVariant_ULong_String::javaClassStatic()->getStaticMethod<jni::local_ref<JVariant_ULong_String>(jni::alias_ref<jni::JString>)>("fromCpp_1");
+    return method(JVariant_ULong_String::javaClassStatic(), value);
+  }
+
+  JVariant_ULong_String_impl::Second::Value JVariant_ULong_String_impl::Second::getValue() const {
+    static const auto field = javaClassStatic()->getField<jni::JString>("value");
+    return getFieldValue(field);
+  }
+
+} // namespace margelo::nitro::test
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JHybridTestObjectSwiftKotlinSpec.hpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JHybridTestObjectSwiftKotlinSpec.hpp
index 5b052a1e1a..dcef6db2ef 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JHybridTestObjectSwiftKotlinSpec.hpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JHybridTestObjectSwiftKotlinSpec.hpp
@@ -38,6 +38,8 @@
 #include <NitroTest/private/JCallback_std__vector_Powertrain__std__vector_Powertrain_.hpp>
 #include <NitroModules/JNIConverter+Promise.hpp>
 #include <NitroModules/JSIConverter+JTypedPromise.hpp>
+#include <NitroTest/private/JVariant_ULong_String.hpp>
+#include <NitroTest/private/JVariant_ULongArray_String.hpp>
 #include <NitroTest/private/JHybridChildSpecJavaPart.hpp>
 #include <NitroTest/private/JCallback_void.hpp>
 #include <NitroModules/AnyJSON.hpp>
@@ -217,6 +219,8 @@ namespace margelo::nitro::test {
     jni::local_ref<JOptional<JArrayUInt64>> bounceOptionalUnsignedArray(const jni::local_ref<JOptional<JArrayUInt64>>& array);
     jni::local_ref<JTypedPromise<jni::local_ref<JArrayUInt64>>> bounceUnsignedArrayAsync(const jni::local_ref<JArrayUInt64>& array);
     jni::local_ref<JArrayUInt64> callUnsignedArrayCallback(const jni::local_ref<JArrayUInt64>& array, const jni::local_ref<margelo::nitro::test::JCallback_std__vector_uint64_t__std__vector_uint64_t_::JavaPart>& callback);
+    jni::local_ref<JVariant_ULong_String> bounceUnsignedVariant(const jni::local_ref<JVariant_ULong_String>& variant);
+    jni::local_ref<JVariant_ULongArray_String> bounceUnsignedArrayVariant(const jni::local_ref<JVariant_ULongArray_String>& variant);
     jni::local_ref<jni::JArrayClass<JHybridChildSpecJavaPart>> bounceHybridObjects(const jni::local_ref<jni::JArrayClass<JHybridChildSpecJavaPart>>& array);
     jni::local_ref<jni::JArrayClass<margelo::nitro::test::JCallback_void::JavaPart>> bounceFunctions(const jni::local_ref<jni::JArrayClass<margelo::nitro::test::JCallback_void::JavaPart>>& functions);
     jni::local_ref<jni::JArrayClass<JAnyJSON>> bounceMaps(const jni::local_ref<jni::JArrayClass<JAnyJSON>>& maps);
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JJsStyleStruct.hpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JJsStyleStruct.hpp
index c432b08cdf..c59a2c34ff 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JJsStyleStruct.hpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JJsStyleStruct.hpp
@@ -34,8 +34,9 @@ namespace margelo::nitro::test {
     }
 
     jni::local_ref<margelo::nitro::test::JCallback_void_double::JavaPart> getOnChanged() const {
-      static const auto method = javaClassStatic()->getMethod<margelo::nitro::test::JCallback_void_double::JavaPart()>("getOnChanged_cxx");
-      return method(this->self());
+      static const auto clazz = javaClassStatic();
+      static const auto method = clazz->getNonvirtualMethod<margelo::nitro::test::JCallback_void_double::JavaPart()>("getOnChanged_cxx");
+      return method(this->self(), clazz);
     }
   };
 
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JUnsignedValues.hpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JUnsignedValues.hpp
index c8b32f0f3e..1cd1fae67f 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JUnsignedValues.hpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JUnsignedValues.hpp
@@ -44,8 +44,9 @@ namespace margelo::nitro::test {
     }
 
     jni::local_ref<JOptional<JUInt64>> getOptionalUnsigned() const {
-      static const auto method = javaClassStatic()->getMethod<JOptional<JUInt64>()>("getOptionalUnsigned_cxx");
-      return method(this->self());
+      static const auto clazz = javaClassStatic();
+      static const auto method = clazz->getNonvirtualMethod<JOptional<JUInt64>()>("getOptionalUnsigned_cxx");
+      return method(this->self(), clazz);
     }
 
     jni::local_ref<JArrayUInt64> getValues() const {
@@ -54,18 +55,21 @@ namespace margelo::nitro::test {
     }
 
     jni::local_ref<jni::JArrayClass<JArrayUInt64>> getNested() const {
-      static const auto method = javaClassStatic()->getMethod<jni::JArrayClass<JArrayUInt64>()>("getNested_cxx");
-      return method(this->self());
+      static const auto clazz = javaClassStatic();
+      static const auto method = clazz->getNonvirtualMethod<jni::JArrayClass<JArrayUInt64>()>("getNested_cxx");
+      return method(this->self(), clazz);
     }
 
     jni::local_ref<jni::JMap<jni::JString, JOptional<JUInt64>>> getRecord() const {
-      static const auto method = javaClassStatic()->getMethod<jni::JMap<jni::JString, JOptional<JUInt64>>()>("getRecord_cxx");
-      return method(this->self());
+      static const auto clazz = javaClassStatic();
+      static const auto method = clazz->getNonvirtualMethod<jni::JMap<jni::JString, JOptional<JUInt64>>()>("getRecord_cxx");
+      return method(this->self(), clazz);
     }
 
     jni::local_ref<jni::JArrayClass<margelo::nitro::test::JCallback_uint64_t_uint64_t::JavaPart>> getCallbacks() const {
-      static const auto method = javaClassStatic()->getMethod<jni::JArrayClass<margelo::nitro::test::JCallback_uint64_t_uint64_t::JavaPart>()>("getCallbacks_cxx");
-      return method(this->self());
+      static const auto clazz = javaClassStatic();
+      static const auto method = clazz->getNonvirtualMethod<jni::JArrayClass<margelo::nitro::test::JCallback_uint64_t_uint64_t::JavaPart>()>("getCallbacks_cxx");
+      return method(this->self(), clazz);
     }
   };
 
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JVariant_ULongArray_String.hpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JVariant_ULongArray_String.hpp
new file mode 100644
index 0000000000..fa1c94244a
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JVariant_ULongArray_String.hpp
@@ -0,0 +1,63 @@
+///
+/// JVariant_ULongArray_String.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <tuple>
+#include <NitroModules/JSIConverter+JNIVariant.hpp>
+#include <NitroModules/JNIConverter+Primitives.hpp>
+#include <NitroModules/JSIConverter+JNIPrimitives.hpp>
+#include <NitroModules/JNIConverter+Array.hpp>
+#include <NitroModules/JSIConverter+JPrimitiveArray.hpp>
+#include <NitroModules/JNIConverter+String.hpp>
+#include <NitroModules/JSIConverter+JString.hpp>
+
+namespace margelo::nitro::test {
+
+  namespace jni = facebook::jni;
+
+  namespace JVariant_ULongArray_String_impl {
+    class First;
+    class Second;
+  }
+
+  /** The JNI representation of Kotlin's sealed Variant_ULongArray_String class. */
+  class JVariant_ULongArray_String : public jni::JavaClass<JVariant_ULongArray_String> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_ULongArray_String;";
+    using Cases = std::tuple<JVariant_ULongArray_String_impl::First, JVariant_ULongArray_String_impl::Second>;
+#ifdef NITRO_DEBUG
+    static constexpr auto diagnosticName = "variant<std::vector<uint64_t>, std::string>";
+#else
+    static constexpr auto diagnosticName = "variant<...>";
+#endif
+
+    [[nodiscard]] size_t getIndex() const;
+  };
+
+  namespace JVariant_ULongArray_String_impl {
+    class First final : public jni::JavaClass<First, JVariant_ULongArray_String> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_ULongArray_String$First;";
+      using Value = jni::local_ref<JArrayUInt64>;
+
+      static jni::local_ref<JVariant_ULongArray_String> create(jni::alias_ref<JArrayUInt64> value);
+      [[nodiscard]] Value getValue() const;
+    };
+
+    class Second final : public jni::JavaClass<Second, JVariant_ULongArray_String> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_ULongArray_String$Second;";
+      using Value = jni::local_ref<jni::JString>;
+
+      static jni::local_ref<JVariant_ULongArray_String> create(jni::alias_ref<jni::JString> value);
+      [[nodiscard]] Value getValue() const;
+    };
+  }
+
+} // namespace margelo::nitro::test
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JVariant_ULong_String.hpp b/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JVariant_ULong_String.hpp
new file mode 100644
index 0000000000..96d2d32934
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/c++/include/NitroTest/private/JVariant_ULong_String.hpp
@@ -0,0 +1,61 @@
+///
+/// JVariant_ULong_String.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <tuple>
+#include <NitroModules/JSIConverter+JNIVariant.hpp>
+#include <NitroModules/JNIConverter+Primitives.hpp>
+#include <NitroModules/JSIConverter+JNIPrimitives.hpp>
+#include <NitroModules/JNIConverter+String.hpp>
+#include <NitroModules/JSIConverter+JString.hpp>
+
+namespace margelo::nitro::test {
+
+  namespace jni = facebook::jni;
+
+  namespace JVariant_ULong_String_impl {
+    class First;
+    class Second;
+  }
+
+  /** The JNI representation of Kotlin's sealed Variant_ULong_String class. */
+  class JVariant_ULong_String : public jni::JavaClass<JVariant_ULong_String> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_ULong_String;";
+    using Cases = std::tuple<JVariant_ULong_String_impl::First, JVariant_ULong_String_impl::Second>;
+#ifdef NITRO_DEBUG
+    static constexpr auto diagnosticName = "variant<uint64_t, std::string>";
+#else
+    static constexpr auto diagnosticName = "variant<...>";
+#endif
+
+    [[nodiscard]] size_t getIndex() const;
+  };
+
+  namespace JVariant_ULong_String_impl {
+    class First final : public jni::JavaClass<First, JVariant_ULong_String> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_ULong_String$First;";
+      using Value = uint64_t;
+
+      static jni::local_ref<JVariant_ULong_String> create(uint64_t value);
+      [[nodiscard]] Value getValue() const;
+    };
+
+    class Second final : public jni::JavaClass<Second, JVariant_ULong_String> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_ULong_String$Second;";
+      using Value = jni::local_ref<jni::JString>;
+
+      static jni::local_ref<JVariant_ULong_String> create(jni::alias_ref<jni::JString> value);
+      [[nodiscard]] Value getValue() const;
+    };
+  }
+
+} // namespace margelo::nitro::test
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/CoreTypesVariant.kt b/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/CoreTypesVariant.kt
index 1ac8e98a70..b4201bf7ea 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/CoreTypesVariant.kt
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/CoreTypesVariant.kt
@@ -22,7 +22,13 @@ sealed class CoreTypesVariant private constructor(@DoNotStrip private val index:
   @DoNotStrip
   data class First(@DoNotStrip val value: ArrayBuffer): CoreTypesVariant(0)
   @DoNotStrip
-  data class Second(@DoNotStrip val value: Callback_void_double): CoreTypesVariant(1)
+  data class Second(@DoNotStrip val value: Callback<(value: Double) -> Unit>): CoreTypesVariant(1) {
+    @DoNotStrip
+    @Suppress("unused", "FunctionName")
+    private fun getValue_cxx(): Callback_void_double {
+      return Callback_void_double.fromKotlin(value)
+    }
+  }
   @DoNotStrip
   data class Third(@DoNotStrip val value: WrappedJsStruct): CoreTypesVariant(2)
   @DoNotStrip
@@ -96,7 +102,7 @@ sealed class CoreTypesVariant private constructor(@DoNotStrip private val index:
     @JvmStatic
     @JvmName("createSecond")
     @DoNotStrip
-    fun create(value: Callback<(value: Double) -> Unit>): CoreTypesVariant = Second(Callback_void_double.fromKotlin(value))
+    fun create(value: Callback<(value: Double) -> Unit>): CoreTypesVariant = Second(value)
 
     @JvmStatic
     @DoNotStrip
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt b/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt
index 639d7b7350..e991ad3d92 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt
@@ -331,6 +331,14 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
     return __result.asLongArray()
   }
 
+  @DoNotStrip
+  @Keep
+  abstract fun bounceUnsignedVariant(variant: Variant_ULong_String): Variant_ULong_String
+
+  @DoNotStrip
+  @Keep
+  abstract fun bounceUnsignedArrayVariant(variant: Variant_ULongArray_String): Variant_ULongArray_String
+
   @DoNotStrip
   @Keep
   abstract fun bounceHybridObjects(array: Array<HybridChildSpec>): Array<HybridChildSpec>
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Callback_______Unit__Double.kt b/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Callback_______Unit__Double.kt
index cfc4ae5b66..aef4236b8c 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Callback_______Unit__Double.kt
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Callback_______Unit__Double.kt
@@ -17,7 +17,13 @@ import com.margelo.nitro.core.Callback
 @DoNotStrip
 sealed class Variant_Callback_______Unit__Double private constructor(@DoNotStrip private val index: Int) {
   @DoNotStrip
-  data class First(@DoNotStrip val value: Callback_void): Variant_Callback_______Unit__Double(0)
+  data class First(@DoNotStrip val value: Callback<() -> Unit>): Variant_Callback_______Unit__Double(0) {
+    @DoNotStrip
+    @Suppress("unused", "FunctionName")
+    private fun getValue_cxx(): Callback_void {
+      return Callback_void.fromKotlin(value)
+    }
+  }
   @DoNotStrip
   data class Second(@DoNotStrip val value: Double): Variant_Callback_______Unit__Double(1)
 
@@ -55,7 +61,7 @@ sealed class Variant_Callback_______Unit__Double private constructor(@DoNotStrip
     @JvmStatic
     @JvmName("createFirst")
     @DoNotStrip
-    fun create(value: Callback<() -> Unit>): Variant_Callback_______Unit__Double = First(Callback_void.fromKotlin(value))
+    fun create(value: Callback<() -> Unit>): Variant_Callback_______Unit__Double = First(value)
 
     @JvmStatic
     @DoNotStrip
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_ULongArray_String.kt b/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_ULongArray_String.kt
new file mode 100644
index 0000000000..333d9ddf4f
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_ULongArray_String.kt
@@ -0,0 +1,72 @@
+///
+/// Variant_ULongArray_String.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test
+
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the TypeScript variant "ULongArray | String".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class Variant_ULongArray_String private constructor(@DoNotStrip private val index: Int) {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: ULongArray): Variant_ULongArray_String(0)
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: String): Variant_ULongArray_String(1)
+
+  inline fun <reified T> asType(): T? {
+    return when (this) {
+      is First -> (value) as? T
+      is Second -> (value) as? T
+    }
+  }
+  inline fun <reified T> isType(): Boolean {
+    return asType<T>() != null
+  }
+  inline fun <R> match(first: (ULongArray) -> R, second: (String) -> R): R {
+    return when (this) {
+      is First -> first(value)
+      is Second -> second(value)
+    }
+  }
+
+  val isFirst: Boolean
+    get() = this is First
+  val isSecond: Boolean
+    get() = this is Second
+
+  fun asFirstOrNull(): ULongArray? {
+    val value = (this as? First)?.value ?: return null
+    return value
+  }
+  fun asSecondOrNull(): String? {
+    val value = (this as? Second)?.value ?: return null
+    return value
+  }
+
+  companion object {
+    @JvmStatic
+    @JvmName("createFirst")
+    @DoNotStrip
+    fun create(value: ULongArray): Variant_ULongArray_String = First(value)
+
+    @JvmStatic
+    @DoNotStrip
+    private fun fromCpp_0(value: LongArray): Variant_ULongArray_String = First(value.asULongArray())
+    @JvmStatic
+    @JvmName("createSecond")
+    @DoNotStrip
+    fun create(value: String): Variant_ULongArray_String = Second(value)
+
+    @JvmStatic
+    @DoNotStrip
+    private fun fromCpp_1(value: String): Variant_ULongArray_String = Second(value)
+  }
+}
diff --git a/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_ULong_String.kt b/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_ULong_String.kt
new file mode 100644
index 0000000000..6200d7738b
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_ULong_String.kt
@@ -0,0 +1,72 @@
+///
+/// Variant_ULong_String.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.test
+
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the TypeScript variant "ULong | String".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class Variant_ULong_String private constructor(@DoNotStrip private val index: Int) {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: ULong): Variant_ULong_String(0)
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: String): Variant_ULong_String(1)
+
+  inline fun <reified T> asType(): T? {
+    return when (this) {
+      is First -> (value) as? T
+      is Second -> (value) as? T
+    }
+  }
+  inline fun <reified T> isType(): Boolean {
+    return asType<T>() != null
+  }
+  inline fun <R> match(first: (ULong) -> R, second: (String) -> R): R {
+    return when (this) {
+      is First -> first(value)
+      is Second -> second(value)
+    }
+  }
+
+  val isFirst: Boolean
+    get() = this is First
+  val isSecond: Boolean
+    get() = this is Second
+
+  fun asFirstOrNull(): ULong? {
+    val value = (this as? First)?.value ?: return null
+    return value
+  }
+  fun asSecondOrNull(): String? {
+    val value = (this as? Second)?.value ?: return null
+    return value
+  }
+
+  companion object {
+    @JvmStatic
+    @JvmName("createFirst")
+    @DoNotStrip
+    fun create(value: ULong): Variant_ULong_String = First(value)
+
+    @JvmStatic
+    @DoNotStrip
+    private fun fromCpp_0(value: Long): Variant_ULong_String = First(value.toULong())
+    @JvmStatic
+    @JvmName("createSecond")
+    @DoNotStrip
+    fun create(value: String): Variant_ULong_String = Second(value)
+
+    @JvmStatic
+    @DoNotStrip
+    private fun fromCpp_1(value: String): Variant_ULong_String = Second(value)
+  }
+}
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/NitroTestAppleCxx/include/NitroTestAppleCxx/NitroTestAppleCxx.h b/tests/standalone/nitro-test/nitrogen/generated/apple/NitroTestAppleCxx/include/NitroTestAppleCxx/NitroTestAppleCxx.h
index 2d04008326..20577a069e 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/apple/NitroTestAppleCxx/include/NitroTestAppleCxx/NitroTestAppleCxx.h
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/NitroTestAppleCxx/include/NitroTestAppleCxx/NitroTestAppleCxx.h
@@ -57,6 +57,10 @@ namespace NitroTest { class TruckPowertrain; }
 namespace NitroTest { class PartialPerson; }
 // Forward declaration of `SwiftContainer_swift__Array___NitroTest__Powertrain_` to properly resolve imports.
 namespace NitroTest { class SwiftContainer_swift__Array___NitroTest__Powertrain_; }
+// Forward declaration of `Variant_UInt64_String_cxx` to properly resolve imports.
+namespace NitroTest { class Variant_UInt64_String_cxx; }
+// Forward declaration of `Variant__UInt64__String_cxx` to properly resolve imports.
+namespace NitroTest { class Variant__UInt64__String_cxx; }
 namespace NitroModules { class AnyJSON; }
 #include <NitroModules/ArrayBuffer.hpp>
 // Forward declaration of `Variant_Bool_Double_cxx` to properly resolve imports.
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectCppSpecClass.cpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectCppSpecClass.cpp
index 240c373dea..076cde2198 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectCppSpecClass.cpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectCppSpecClass.cpp
@@ -152,6 +152,8 @@ namespace margelo::nitro::test {
       clazz.registerHybridMethod("bounceOptionalUnsignedArray", &HybridTestObjectCppSpec::bounceOptionalUnsignedArray);
       clazz.registerHybridMethod("bounceUnsignedArrayAsync", &HybridTestObjectCppSpec::bounceUnsignedArrayAsync);
       clazz.registerHybridMethod("callUnsignedArrayCallback", &HybridTestObjectCppSpec::callUnsignedArrayCallback);
+      clazz.registerHybridMethod("bounceUnsignedVariant", &HybridTestObjectCppSpec::bounceUnsignedVariant);
+      clazz.registerHybridMethod("bounceUnsignedArrayVariant", &HybridTestObjectCppSpec::bounceUnsignedArrayVariant);
       clazz.registerHybridMethod("bounceHybridObjects", &HybridTestObjectCppSpec::bounceHybridObjects);
       clazz.registerHybridMethod("bounceFunctions", &HybridTestObjectCppSpec::bounceFunctions);
       clazz.registerHybridMethod("bounceMaps", &HybridTestObjectCppSpec::bounceMaps);
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectSwiftKotlinSpecSwift.cpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectSwiftKotlinSpecSwift.cpp
index 3fa47dd5f2..d456ae99e1 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectSwiftKotlinSpecSwift.cpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/HybridTestObjectSwiftKotlinSpecSwift.cpp
@@ -429,6 +429,26 @@ namespace margelo::nitro::test {
     return std::move(__result.value());
   }
 
+  ::NitroTest::Variant_UInt64_String_cxx HybridTestObjectSwiftKotlinSpecSwift::bounceUnsignedVariant(const ::NitroTest::Variant_UInt64_String_cxx& variant) {
+    auto __result = withSwiftResult<::NitroTest::Variant_UInt64_String_cxx>([&](void* __outResult) {
+      return _swiftPart.bounceUnsignedVariant(variant, __outResult);
+    });
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
+  ::NitroTest::Variant__UInt64__String_cxx HybridTestObjectSwiftKotlinSpecSwift::bounceUnsignedArrayVariant(const ::NitroTest::Variant__UInt64__String_cxx& variant) {
+    auto __result = withSwiftResult<::NitroTest::Variant__UInt64__String_cxx>([&](void* __outResult) {
+      return _swiftPart.bounceUnsignedArrayVariant(variant, __outResult);
+    });
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
   swift::Array<::NitroTest::HybridChildSpec_cxx> HybridTestObjectSwiftKotlinSpecSwift::bounceHybridObjects(const swift::Array<::NitroTest::HybridChildSpec_cxx>& array) {
     auto __result = withSwiftResult<swift::Array<::NitroTest::HybridChildSpec_cxx>>([&](void* __outResult) {
       return _swiftPart.bounceHybridObjects(array, __outResult);
@@ -1676,6 +1696,8 @@ namespace margelo::nitro::test {
       clazz.registerHybridMethod("bounceOptionalUnsignedArray", &HybridTestObjectSwiftKotlinSpecSwift::bounceOptionalUnsignedArray);
       clazz.registerHybridMethod("bounceUnsignedArrayAsync", &HybridTestObjectSwiftKotlinSpecSwift::bounceUnsignedArrayAsync);
       clazz.registerHybridMethod("callUnsignedArrayCallback", &HybridTestObjectSwiftKotlinSpecSwift::callUnsignedArrayCallback);
+      clazz.registerHybridMethod("bounceUnsignedVariant", &HybridTestObjectSwiftKotlinSpecSwift::bounceUnsignedVariant);
+      clazz.registerHybridMethod("bounceUnsignedArrayVariant", &HybridTestObjectSwiftKotlinSpecSwift::bounceUnsignedArrayVariant);
       clazz.registerHybridMethod("bounceHybridObjects", &HybridTestObjectSwiftKotlinSpecSwift::bounceHybridObjects);
       clazz.registerHybridMethod("bounceFunctions", &HybridTestObjectSwiftKotlinSpecSwift::bounceFunctions);
       clazz.registerHybridMethod("bounceMaps", &HybridTestObjectSwiftKotlinSpecSwift::bounceMaps);
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/Variant_UInt64_String-Swift.cpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/Variant_UInt64_String-Swift.cpp
new file mode 100644
index 0000000000..eaf0274951
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/Variant_UInt64_String-Swift.cpp
@@ -0,0 +1,41 @@
+///
+/// Variant_UInt64_String-Swift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <NitroTest/private/Variant_UInt64_String-Swift.hpp>
+#include <NitroTest/private/NitroTest-Swift-Cxx-Umbrella.hpp>
+
+namespace margelo::nitro {
+
+  ::NitroTest::Variant_UInt64_String_cxx JSIConverter<::NitroTest::Variant_UInt64_String_cxx>::fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (JSIConverter<uint64_t>::canConvert(runtime, value)) {
+      auto payload = JSIConverter<uint64_t>::fromJSI(runtime, value);
+      return NitroModules::makeSwiftValue<::NitroTest::Variant_UInt64_String_cxx>([&](void* result) {
+        ::NitroTest::Variant_UInt64_String_cxx::initializeFirst(payload, result);
+      });
+    }
+    if (JSIConverter<swift::String>::canConvert(runtime, value)) {
+      auto payload = JSIConverter<swift::String>::fromJSI(runtime, value);
+      return NitroModules::makeSwiftValue<::NitroTest::Variant_UInt64_String_cxx>([&](void* result) {
+        ::NitroTest::Variant_UInt64_String_cxx::initializeSecond(payload, result);
+      });
+    }
+    throw std::runtime_error("Cannot convert \"" + value.toString(runtime).utf8(runtime) + "\" to any type in variant<uint64_t, std::string>!");
+  }
+
+  jsi::Value JSIConverter<::NitroTest::Variant_UInt64_String_cxx>::toJSI(jsi::Runtime& runtime, const ::NitroTest::Variant_UInt64_String_cxx& value) {
+    switch (value.getIndex()) {
+      case 0: return JSIConverter<uint64_t>::toJSI(runtime, value.getFirst());
+      case 1: return JSIConverter<swift::String>::toJSI(runtime, value.getSecond());
+      default: throw std::invalid_argument("Invalid variant index");
+    }
+  }
+
+  bool JSIConverter<::NitroTest::Variant_UInt64_String_cxx>::canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    return JSIConverter<uint64_t>::canConvert(runtime, value) || JSIConverter<swift::String>::canConvert(runtime, value);
+  }
+
+} // namespace margelo::nitro
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/Variant__UInt64__String-Swift.cpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/Variant__UInt64__String-Swift.cpp
new file mode 100644
index 0000000000..9da29e2d2a
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/Variant__UInt64__String-Swift.cpp
@@ -0,0 +1,41 @@
+///
+/// Variant__UInt64__String-Swift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <NitroTest/private/Variant__UInt64__String-Swift.hpp>
+#include <NitroTest/private/NitroTest-Swift-Cxx-Umbrella.hpp>
+
+namespace margelo::nitro {
+
+  ::NitroTest::Variant__UInt64__String_cxx JSIConverter<::NitroTest::Variant__UInt64__String_cxx>::fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (JSIConverter<swift::Array<uint64_t>>::canConvert(runtime, value)) {
+      auto payload = JSIConverter<swift::Array<uint64_t>>::fromJSI(runtime, value);
+      return NitroModules::makeSwiftValue<::NitroTest::Variant__UInt64__String_cxx>([&](void* result) {
+        ::NitroTest::Variant__UInt64__String_cxx::initializeFirst(payload, result);
+      });
+    }
+    if (JSIConverter<swift::String>::canConvert(runtime, value)) {
+      auto payload = JSIConverter<swift::String>::fromJSI(runtime, value);
+      return NitroModules::makeSwiftValue<::NitroTest::Variant__UInt64__String_cxx>([&](void* result) {
+        ::NitroTest::Variant__UInt64__String_cxx::initializeSecond(payload, result);
+      });
+    }
+    throw std::runtime_error("Cannot convert \"" + value.toString(runtime).utf8(runtime) + "\" to any type in variant<std::vector<uint64_t>, std::string>!");
+  }
+
+  jsi::Value JSIConverter<::NitroTest::Variant__UInt64__String_cxx>::toJSI(jsi::Runtime& runtime, const ::NitroTest::Variant__UInt64__String_cxx& value) {
+    switch (value.getIndex()) {
+      case 0: return JSIConverter<swift::Array<uint64_t>>::toJSI(runtime, value.getFirst());
+      case 1: return JSIConverter<swift::String>::toJSI(runtime, value.getSecond());
+      default: throw std::invalid_argument("Invalid variant index");
+    }
+  }
+
+  bool JSIConverter<::NitroTest::Variant__UInt64__String_cxx>::canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    return JSIConverter<swift::Array<uint64_t>>::canConvert(runtime, value) || JSIConverter<swift::String>::canConvert(runtime, value);
+  }
+
+} // namespace margelo::nitro
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/HybridTestObjectSwiftKotlinSpecSwift.hpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/HybridTestObjectSwiftKotlinSpecSwift.hpp
index 705a322fe0..33c552d5f4 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/HybridTestObjectSwiftKotlinSpecSwift.hpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/HybridTestObjectSwiftKotlinSpecSwift.hpp
@@ -125,6 +125,8 @@ namespace margelo::nitro::test {
     swift::Optional<swift::Array<uint64_t>> bounceOptionalUnsignedArray(const swift::Optional<swift::Array<uint64_t>>& array);
     Promise<swift::Array<uint64_t>> bounceUnsignedArrayAsync(const swift::Array<uint64_t>& array);
     swift::Array<uint64_t> callUnsignedArrayCallback(const swift::Array<uint64_t>& array, const Callback<swift::Array<uint64_t>(const swift::Array<uint64_t>&)>& callback);
+    ::NitroTest::Variant_UInt64_String_cxx bounceUnsignedVariant(const ::NitroTest::Variant_UInt64_String_cxx& variant);
+    ::NitroTest::Variant__UInt64__String_cxx bounceUnsignedArrayVariant(const ::NitroTest::Variant__UInt64__String_cxx& variant);
     swift::Array<::NitroTest::HybridChildSpec_cxx> bounceHybridObjects(const swift::Array<::NitroTest::HybridChildSpec_cxx>& array);
     swift::Array<Callback<void()>> bounceFunctions(const swift::Array<Callback<void()>>& functions);
     swift::Array<NitroModules::AnyJSON> bounceMaps(const swift::Array<NitroModules::AnyJSON>& maps);
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/NitroTest-Swift-Cxx-Umbrella.hpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/NitroTest-Swift-Cxx-Umbrella.hpp
index 191836db04..714644bfe2 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/NitroTest-Swift-Cxx-Umbrella.hpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/NitroTest-Swift-Cxx-Umbrella.hpp
@@ -65,6 +65,8 @@
 #include <NitroTest/private/TruckPowertrain-Swift.hpp>
 #include <NitroTest/private/PartialPerson-Swift.hpp>
 #include <NitroTest/private/SwiftContainer_swift__Array___NitroTest__Powertrain_-Swift.hpp>
+#include <NitroTest/private/Variant_UInt64_String-Swift.hpp>
+#include <NitroTest/private/Variant__UInt64__String-Swift.hpp>
 #include <NitroModules/JSIConverter+SwiftAnyJSON.hpp>
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroTest/private/Variant_Bool_Double-Swift.hpp>
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/Variant_UInt64_String-Swift.hpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/Variant_UInt64_String-Swift.hpp
new file mode 100644
index 0000000000..46011b8fa8
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/Variant_UInt64_String-Swift.hpp
@@ -0,0 +1,23 @@
+///
+/// Variant_UInt64_String-Swift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JSIConverter.hpp>
+// Forward declaration of `Variant_UInt64_String_cxx` to properly resolve imports.
+namespace NitroTest { class Variant_UInt64_String_cxx; }
+
+namespace margelo::nitro {
+
+  template <>
+  struct JSIConverter<::NitroTest::Variant_UInt64_String_cxx> {
+    static ::NitroTest::Variant_UInt64_String_cxx fromJSI(jsi::Runtime& runtime, const jsi::Value& value);
+    static jsi::Value toJSI(jsi::Runtime& runtime, const ::NitroTest::Variant_UInt64_String_cxx& value);
+    static bool canConvert(jsi::Runtime& runtime, const jsi::Value& value);
+  };
+
+} // namespace margelo::nitro
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/Variant__UInt64__String-Swift.hpp b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/Variant__UInt64__String-Swift.hpp
new file mode 100644
index 0000000000..1ea640aa46
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/c++/include/NitroTest/private/Variant__UInt64__String-Swift.hpp
@@ -0,0 +1,23 @@
+///
+/// Variant__UInt64__String-Swift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JSIConverter.hpp>
+// Forward declaration of `Variant__UInt64__String_cxx` to properly resolve imports.
+namespace NitroTest { class Variant__UInt64__String_cxx; }
+
+namespace margelo::nitro {
+
+  template <>
+  struct JSIConverter<::NitroTest::Variant__UInt64__String_cxx> {
+    static ::NitroTest::Variant__UInt64__String_cxx fromJSI(jsi::Runtime& runtime, const jsi::Value& value);
+    static jsi::Value toJSI(jsi::Runtime& runtime, const ::NitroTest::Variant__UInt64__String_cxx& value);
+    static bool canConvert(jsi::Runtime& runtime, const jsi::Value& value);
+  };
+
+} // namespace margelo::nitro
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec.swift b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec.swift
index a8aeb43243..2d6619b9b0 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec.swift
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec.swift
@@ -63,6 +63,8 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: HybridTestObjectSwiftK
   func bounceOptionalUnsignedArray(array: [UInt64]?) throws -> [UInt64]?
   func bounceUnsignedArrayAsync(array: [UInt64]) throws -> any Promise<[UInt64]>
   func callUnsignedArrayCallback(array: [UInt64], callback: any Callback<(/* array */ [UInt64]), [UInt64]>) throws -> [UInt64]
+  func bounceUnsignedVariant(variant: Variant_UInt64_String) throws -> Variant_UInt64_String
+  func bounceUnsignedArrayVariant(variant: Variant__UInt64__String) throws -> Variant__UInt64__String
   func bounceHybridObjects(array: [(any HybridChildSpec)]) throws -> [(any HybridChildSpec)]
   func bounceFunctions(functions: [any Callback<(), Void>]) throws -> [any Callback<(), Void>]
   func bounceMaps(maps: [AnyJSON]) throws -> [AnyJSON]
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift
index e4cc9de133..cad5a58c42 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift
@@ -559,6 +559,26 @@ public final class HybridTestObjectSwiftKotlinSpec_cxx {
     }
   }
 
+  public final func bounceUnsignedVariant(variant: Variant_UInt64_String_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void {
+    do {
+      let value = try __implementation.bounceUnsignedVariant(variant: variant.value)
+      __outResult.assumingMemoryBound(to: Variant_UInt64_String_cxx.self).initialize(to: Variant_UInt64_String_cxx(value))
+      return bridge.Result_void.withValue()
+    } catch {
+      return bridge.Result_void.withError(error.toCpp())
+    }
+  }
+
+  public final func bounceUnsignedArrayVariant(variant: Variant__UInt64__String_cxx, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void {
+    do {
+      let value = try __implementation.bounceUnsignedArrayVariant(variant: variant.value)
+      __outResult.assumingMemoryBound(to: Variant__UInt64__String_cxx.self).initialize(to: Variant__UInt64__String_cxx(value))
+      return bridge.Result_void.withValue()
+    } catch {
+      return bridge.Result_void.withError(error.toCpp())
+    }
+  }
+
   public final func bounceHybridObjects(array: [HybridChildSpec_cxx], __outResult: UnsafeMutableRawPointer) -> bridge.Result_void {
     do {
       let value = try __implementation.bounceHybridObjects(array: array.map { $0.getHybridChildSpec() })
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/Variant_UInt64_String.swift b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/Variant_UInt64_String.swift
new file mode 100644
index 0000000000..dceba1219c
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/Variant_UInt64_String.swift
@@ -0,0 +1,69 @@
+///
+/// Variant_UInt64_String.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+internal import NitroModules
+
+/**
+ * A Swift enum with associated values representing a Variant/Union type.
+ * JS type: `uint64 | string`
+ */
+@frozen
+public enum Variant_UInt64_String: Equatable, Hashable, Sendable {
+  case first(UInt64)
+  case second(String)
+}
+
+public extension Variant_UInt64_String {
+  func asType<T>(_ type: T.Type = T.self) -> T? {
+    switch self {
+      case .first(let value): return value as? T
+      case .second(let value): return value as? T
+    }
+  }
+  func isType<T>(_ type: T.Type = T.self) -> Bool {
+    return self.asType(type) != nil
+  }
+}
+
+// Raw Swift storage keeps associated values containing imported C++ types exportable.
+@_expose(Cxx)
+public struct Variant_UInt64_String_cxx: Equatable, Hashable, Sendable {
+  let value: Variant_UInt64_String
+
+  init(_ value: Variant_UInt64_String) {
+    self.value = value
+  }
+
+  public var index: Int {
+    switch value {
+      case .first: return 0
+      case .second: return 1
+    }
+  }
+
+  @_spi(NitroCxx)
+  public static func initializeFirst(_ payload: UInt64, result: UnsafeMutableRawPointer) {
+    result.assumingMemoryBound(to: Variant_UInt64_String_cxx.self).initialize(to: Self(.first(payload)))
+  }
+
+  @_spi(NitroCxx)
+  public borrowing func getFirst() -> UInt64 {
+    guard case .first(let payload) = value else { preconditionFailure("Invalid variant case") }
+    return payload
+  }
+
+  @_spi(NitroCxx)
+  public static func initializeSecond(_ payload: String, result: UnsafeMutableRawPointer) {
+    result.assumingMemoryBound(to: Variant_UInt64_String_cxx.self).initialize(to: Self(.second(payload)))
+  }
+
+  @_spi(NitroCxx)
+  public borrowing func getSecond() -> String {
+    guard case .second(let payload) = value else { preconditionFailure("Invalid variant case") }
+    return payload
+  }
+}
diff --git a/tests/standalone/nitro-test/nitrogen/generated/apple/swift/Variant__UInt64__String.swift b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/Variant__UInt64__String.swift
new file mode 100644
index 0000000000..d2326aa22c
--- /dev/null
+++ b/tests/standalone/nitro-test/nitrogen/generated/apple/swift/Variant__UInt64__String.swift
@@ -0,0 +1,69 @@
+///
+/// Variant__UInt64__String.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+internal import NitroModules
+
+/**
+ * A Swift enum with associated values representing a Variant/Union type.
+ * JS type: `array | string`
+ */
+@frozen
+public enum Variant__UInt64__String: Equatable, Hashable, Sendable {
+  case first([UInt64])
+  case second(String)
+}
+
+public extension Variant__UInt64__String {
+  func asType<T>(_ type: T.Type = T.self) -> T? {
+    switch self {
+      case .first(let value): return value as? T
+      case .second(let value): return value as? T
+    }
+  }
+  func isType<T>(_ type: T.Type = T.self) -> Bool {
+    return self.asType(type) != nil
+  }
+}
+
+// Raw Swift storage keeps associated values containing imported C++ types exportable.
+@_expose(Cxx)
+public struct Variant__UInt64__String_cxx: Equatable, Hashable, Sendable {
+  let value: Variant__UInt64__String
+
+  init(_ value: Variant__UInt64__String) {
+    self.value = value
+  }
+
+  public var index: Int {
+    switch value {
+      case .first: return 0
+      case .second: return 1
+    }
+  }
+
+  @_spi(NitroCxx)
+  public static func initializeFirst(_ payload: [UInt64], result: UnsafeMutableRawPointer) {
+    result.assumingMemoryBound(to: Variant__UInt64__String_cxx.self).initialize(to: Self(.first(payload)))
+  }
+
+  @_spi(NitroCxx)
+  public borrowing func getFirst() -> [UInt64] {
+    guard case .first(let payload) = value else { preconditionFailure("Invalid variant case") }
+    return payload
+  }
+
+  @_spi(NitroCxx)
+  public static func initializeSecond(_ payload: String, result: UnsafeMutableRawPointer) {
+    result.assumingMemoryBound(to: Variant__UInt64__String_cxx.self).initialize(to: Self(.second(payload)))
+  }
+
+  @_spi(NitroCxx)
+  public borrowing func getSecond() -> String {
+    guard case .second(let payload) = value else { preconditionFailure("Invalid variant case") }
+    return payload
+  }
+}
diff --git a/tests/standalone/nitro-test/nitrogen/generated/shared/c++/include/NitroTest/HybridTestObjectCppSpec.hpp b/tests/standalone/nitro-test/nitrogen/generated/shared/c++/include/NitroTest/HybridTestObjectCppSpec.hpp
index e709415a47..9725c0aa9b 100644
--- a/tests/standalone/nitro-test/nitrogen/generated/shared/c++/include/NitroTest/HybridTestObjectCppSpec.hpp
+++ b/tests/standalone/nitro-test/nitrogen/generated/shared/c++/include/NitroTest/HybridTestObjectCppSpec.hpp
@@ -171,6 +171,8 @@ namespace margelo::nitro::test {
       virtual std::optional<std::vector<uint64_t>> bounceOptionalUnsignedArray(const std::optional<std::vector<uint64_t>>& array) = 0;
       virtual Promise<std::vector<uint64_t>> bounceUnsignedArrayAsync(const std::vector<uint64_t>& array) = 0;
       virtual std::vector<uint64_t> callUnsignedArrayCallback(const std::vector<uint64_t>& array, const Callback<std::vector<uint64_t>(const std::vector<uint64_t>& /* array */)>& callback) = 0;
+      virtual std::variant<uint64_t, std::string> bounceUnsignedVariant(const std::variant<uint64_t, std::string>& variant) = 0;
+      virtual std::variant<std::vector<uint64_t>, std::string> bounceUnsignedArrayVariant(const std::variant<std::vector<uint64_t>, std::string>& variant) = 0;
       virtual std::vector<HybridChildSpecCxx> bounceHybridObjects(const std::vector<HybridChildSpecCxx>& array) = 0;
       virtual std::vector<Callback<void()>> bounceFunctions(const std::vector<Callback<void()>>& functions) = 0;
       virtual std::vector<AnyJSON> bounceMaps(const std::vector<AnyJSON>& maps) = 0;
diff --git a/tests/standalone/nitro-test/specs/TestObject.nitro.ts b/tests/standalone/nitro-test/specs/TestObject.nitro.ts
index 97483d0d9b..8d49379cc9 100644
--- a/tests/standalone/nitro-test/specs/TestObject.nitro.ts
+++ b/tests/standalone/nitro-test/specs/TestObject.nitro.ts
@@ -237,6 +237,8 @@ export declare class TestObjectCpp extends HybridObject {
   bounceOptionalUnsignedArray(array?: UInt64[]): UInt64[] | undefined
   bounceUnsignedArrayAsync(array: UInt64[]): Promise<UInt64[]>
   callUnsignedArrayCallback(array: UInt64[], callback: (array: UInt64[]) => UInt64[]): UInt64[]
+  bounceUnsignedVariant(variant: UInt64 | string): UInt64 | string
+  bounceUnsignedArrayVariant(variant: UInt64[] | string): UInt64[] | string
 
   // Arrays (complex)
   bounceHybridObjects(array: Child[]): Child[]
@@ -528,6 +530,8 @@ export declare class TestObjectSwiftKotlin extends HybridObject {
   bounceOptionalUnsignedArray(array?: UInt64[]): UInt64[] | undefined
   bounceUnsignedArrayAsync(array: UInt64[]): Promise<UInt64[]>
   callUnsignedArrayCallback(array: UInt64[], callback: (array: UInt64[]) => UInt64[]): UInt64[]
+  bounceUnsignedVariant(variant: UInt64 | string): UInt64 | string
+  bounceUnsignedArrayVariant(variant: UInt64[] | string): UInt64[] | string
 
   // Arrays (complex)
   bounceHybridObjects(array: Child[]): Child[]
diff --git a/tests/standalone/test-runner/js/data.test.ts b/tests/standalone/test-runner/js/data.test.ts
index e8ae786cd1..40f56e2f1a 100644
--- a/tests/standalone/test-runner/js/data.test.ts
+++ b/tests/standalone/test-runner/js/data.test.ts
@@ -184,6 +184,19 @@ export const cases = {
       expect(received).to.deep.equal([UNSIGNED_BOUNDARIES])
       expect(result).to.deep.equal([...UNSIGNED_BOUNDARIES].reverse())
     },
+
+    'bounceUnsignedVariant(...) preserves all 64 bits and strings': (testObject) => {
+      for (const unsigned of UNSIGNED_BOUNDARIES) {
+        expect(testObject.bounceUnsignedVariant(unsigned)).to.equal(unsigned)
+      }
+      expect(testObject.bounceUnsignedVariant('18446744073709551615')).to.equal('18446744073709551615')
+    },
+
+    'bounceUnsignedArrayVariant(...) preserves arrays and strings': (testObject) => {
+      expect(testObject.bounceUnsignedArrayVariant(UNSIGNED_BOUNDARIES)).to.deep.equal(UNSIGNED_BOUNDARIES)
+      expect(testObject.bounceUnsignedArrayVariant([])).to.deep.equal([])
+      expect(testObject.bounceUnsignedArrayVariant('values')).to.equal('values')
+    },
   }),
   ...casesForTestObjects('Struct roundtrips', {
     'bouncePartialStruct(...) keeps an empty struct': (testObject) => {