diff --git a/example/src/getTests.ts b/example/src/getTests.ts
index 6dfdcc989e..a9b0199b60 100644
--- a/example/src/getTests.ts
+++ b/example/src/getTests.ts
@@ -1023,7 +1023,7 @@ export function getTests(
           // @ts-expect-error
           (testObject.someVariant = false)
       ).didThrow(
-        `Error: ${testObject.name}.someVariant: Cannot convert "false" to any type in ${debugOnly('variant<std::string, double>!')}`
+        `Error: ${testObject.name}.someVariant: Cannot convert "false" to any type in ${debugOnly('variant<double, std::string>!')}`
       )
     ),
 
@@ -1147,15 +1147,39 @@ export function getTests(
     createTest('getVariantEnum(...) throws at wrong type (string)', () =>
       // @ts-expect-error
       it(() => testObject.getVariantEnum('string')).didThrow(
-        `Error: ${testObject.name}.getVariantEnum(...): Cannot convert "string" to any type in ${debugOnly('variant<bool, margelo::nitro::test::OldEnum>!')}`
+        `Error: ${testObject.name}.getVariantEnum(...): Cannot convert "string" to any type in ${debugOnly('variant<margelo::nitro::test::OldEnum, bool>!')}`
       )
     ),
     createTest('getVariantEnum(...) throws at too high numerical value', () =>
       // @ts-expect-error
       it(() => testObject.getVariantEnum(9999)).didThrow(
-        `Error: ${testObject.name}.getVariantEnum(...): Cannot convert "9999" to any type in ${debugOnly('variant<bool, margelo::nitro::test::OldEnum>!')}`
+        `Error: ${testObject.name}.getVariantEnum(...): Cannot convert "9999" to any type in ${debugOnly('variant<margelo::nitro::test::OldEnum, bool>!')}`
       )
     ),
+    createTest("bounceVariantUnionEnum(...) converts 'gas'", () =>
+      it(() => testObject.bounceVariantUnionEnum('gas'))
+        .didNotThrow()
+        .equals('gas')
+    ),
+    createTest('bounceVariantUnionEnum(...) converts Car', () =>
+      it(() => testObject.bounceVariantUnionEnum(TEST_CAR))
+        .didNotThrow()
+        .equals(TEST_CAR)
+    ),
+    createTest('bounceVariantUnionEnum(...) throws at wrong string', () =>
+      // @ts-expect-error
+      it(() => testObject.bounceVariantUnionEnum('diesel')).didThrow()
+    ),
+    createTest('bounceVariantUnionEnum(...) throws at wrong object', () =>
+      // @ts-expect-error
+      it(() => testObject.bounceVariantUnionEnum({})).didThrow()
+    ),
+    createTest(
+      'bounceVariantUnionEnum(...) throws at wrong type (boolean)',
+      () =>
+        // @ts-expect-error
+        it(() => testObject.bounceVariantUnionEnum(true)).didThrow()
+    ),
     createTest('getVariantWeirdNumbersEnum(...) converts enum', () =>
       it(() => testObject.getVariantWeirdNumbersEnum(WeirdNumbersEnum.C))
         .didNotThrow()
@@ -1171,7 +1195,7 @@ export function getTests(
       () =>
         // @ts-expect-error
         it(() => testObject.getVariantWeirdNumbersEnum('string')).didThrow(
-          `Error: ${testObject.name}.getVariantWeirdNumbersEnum(...): Cannot convert "string" to any type in ${debugOnly('variant<bool, margelo::nitro::test::WeirdNumbersEnum>!')}`
+          `Error: ${testObject.name}.getVariantWeirdNumbersEnum(...): Cannot convert "string" to any type in ${debugOnly('variant<margelo::nitro::test::WeirdNumbersEnum, bool>!')}`
         )
     ),
     createTest(
@@ -1179,7 +1203,7 @@ export function getTests(
       () =>
         // @ts-expect-error
         it(() => testObject.getVariantWeirdNumbersEnum(99999)).didThrow(
-          `Error: ${testObject.name}.getVariantWeirdNumbersEnum(...): Cannot convert "99999" to any type in ${debugOnly('variant<bool, margelo::nitro::test::WeirdNumbersEnum>!')}`
+          `Error: ${testObject.name}.getVariantWeirdNumbersEnum(...): Cannot convert "99999" to any type in ${debugOnly('variant<margelo::nitro::test::WeirdNumbersEnum, bool>!')}`
         )
     ),
     createTest('getVariantObjects(...) converts Person', () =>
@@ -1202,7 +1226,7 @@ export function getTests(
     createTest('getVariantObjects(...) throws at wrong type (string)', () =>
       // @ts-expect-error
       it(() => testObject.getVariantObjects('some-string')).didThrow(
-        `Error: ${testObject.name}.getVariantObjects(...): Cannot convert "some-string" to any type in ${debugOnly('variant<margelo::nitro::test::Car, margelo::nitro::test::Person>!')}`
+        `Error: ${testObject.name}.getVariantObjects(...): Cannot convert "some-string" to any type in ${debugOnly('variant<margelo::nitro::test::Person, margelo::nitro::test::Car>!')}`
       )
     ),
     createTest(
@@ -1212,7 +1236,7 @@ export function getTests(
           // @ts-expect-error
           testObject.getVariantObjects({ someValue: 55 })
         ).didThrow(
-          `Error: ${testObject.name}.getVariantObjects(...): Cannot convert "[object Object]" to any type in ${debugOnly('variant<margelo::nitro::test::Car, margelo::nitro::test::Person>!')}`
+          `Error: ${testObject.name}.getVariantObjects(...): Cannot convert "[object Object]" to any type in ${debugOnly('variant<margelo::nitro::test::Person, margelo::nitro::test::Car>!')}`
         )
     ),
     createTest('getVariantHybrid(...) converts Hybrid', () =>
diff --git a/packages/nitrogen/src/createPlatformSpec.ts b/packages/nitrogen/src/createPlatformSpec.ts
index 19ec88e60b..949dbbbce9 100644
--- a/packages/nitrogen/src/createPlatformSpec.ts
+++ b/packages/nitrogen/src/createPlatformSpec.ts
@@ -113,14 +113,24 @@ function getHybridObjectSpec(type: Type, language: Language): HybridObjectSpec {
       const t = declaration.getType()
       const isOptional =
         prop.isOptional() || t.getUnionTypes().some((u) => u.isUndefined())
-      const propType = createType(language, t, isOptional)
+      const propType = createType(
+        language,
+        t,
+        isOptional,
+        declaration.getTypeNode()
+      )
       properties.push(
         new Property(prop.getName(), propType, declaration.isReadonly())
       )
     } else if (Node.isMethodSignature(declaration)) {
       const returnType = declaration.getReturnType()
       const isOptional = returnType.getUnionTypes().some((t) => t.isUndefined())
-      const methodReturnType = createType(language, returnType, isOptional)
+      const methodReturnType = createType(
+        language,
+        returnType,
+        isOptional,
+        declaration.getReturnTypeNode()
+      )
       const methodParameters = declaration
         .getParameters()
         .map((p) => new Parameter(p, language))
diff --git a/packages/nitrogen/src/syntax/Parameter.ts b/packages/nitrogen/src/syntax/Parameter.ts
index 3d7d7857f6..9384ea17ae 100644
--- a/packages/nitrogen/src/syntax/Parameter.ts
+++ b/packages/nitrogen/src/syntax/Parameter.ts
@@ -26,7 +26,13 @@ export class Parameter implements CodeNode {
       const type = param.getType()
       const isOptional =
         param.hasQuestionToken() || param.isOptional() || type.isNullable()
-      this.type = createNamedType(language, name, type, isOptional)
+      this.type = createNamedType(
+        language,
+        name,
+        type,
+        isOptional,
+        param.getTypeNode()
+      )
     } else {
       // constructor(...)???
       throw new Error(`Invalid constructor! Arguments: ${args}`)
diff --git a/packages/nitrogen/src/syntax/createType.ts b/packages/nitrogen/src/syntax/createType.ts
index 36ac201fa3..d28512c9c0 100644
--- a/packages/nitrogen/src/syntax/createType.ts
+++ b/packages/nitrogen/src/syntax/createType.ts
@@ -1,4 +1,4 @@
-import { ts, Type as TSMorphType, type Signature } from 'ts-morph'
+import { Node, ts, Type as TSMorphType, type Signature } from 'ts-morph'
 import type { Type } from './types/Type.js'
 import { BooleanType } from './types/BooleanType.js'
 import { NumberType } from './types/NumberType.js'
@@ -83,6 +83,54 @@ type Tuple<
   N extends number,
   R extends unknown[] = [],
 > = R['length'] extends N ? R : Tuple<T, N, [T, ...R]>
+
+type TypeNode = Node<ts.TypeNode>
+
+interface UnionConstituent {
+  type: TSMorphType
+  typeNode?: TypeNode
+}
+
+function getAliasTypeNode(type: TSMorphType): TypeNode | undefined {
+  const symbol = type.getNonNullableType().getAliasSymbol()
+  const declaration = symbol?.getDeclarations()[0]
+  if (declaration != null && Node.isTypeAliasDeclaration(declaration)) {
+    return declaration.getTypeNode()
+  }
+  return undefined
+}
+
+function getUnionTypeNodes(
+  type: TSMorphType,
+  typeNode?: TypeNode
+): TypeNode[] | undefined {
+  if (typeNode != null && Node.isUnionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes()
+  }
+
+  const aliasTypeNode = getAliasTypeNode(type)
+  if (aliasTypeNode != null && Node.isUnionTypeNode(aliasTypeNode)) {
+    return aliasTypeNode.getTypeNodes()
+  }
+
+  return undefined
+}
+
+function getUnionConstituents(
+  type: TSMorphType,
+  typeNode?: TypeNode
+): UnionConstituent[] {
+  const typeNodes = getUnionTypeNodes(type, typeNode)
+  if (typeNodes != null) {
+    return typeNodes.map((node) => ({
+      type: node.getType(),
+      typeNode: node,
+    }))
+  }
+
+  return type.getUnionTypes().map((unionType) => ({ type: unionType }))
+}
+
 function getArguments<N extends number>(
   type: TSMorphType,
   typename: string,
@@ -107,14 +155,18 @@ export function createNamedType(
   language: Language,
   name: string,
   type: TSMorphType,
-  isOptional: boolean
+  isOptional: boolean,
+  typeNode?: TypeNode
 ) {
   if (name.startsWith('__')) {
     throw new Error(
       `Name cannot start with two underscores (__) as this is reserved syntax for Nitrogen! (In ${type.getText()})`
     )
   }
-  return new NamedWrappingType(name, createType(language, type, isOptional))
+  return new NamedWrappingType(
+    name,
+    createType(language, type, isOptional, typeNode)
+  )
 }
 
 export function createVoidType(): Type {
@@ -171,7 +223,8 @@ export function addKnownType(
 export function createType(
   language: Language,
   type: TSMorphType,
-  isOptional: boolean
+  isOptional: boolean,
+  typeNode?: TypeNode
 ): Type {
   const key = getTypeId(type, isOptional)
   if (key != null && knownTypes[language].has(key)) {
@@ -183,7 +236,7 @@ export function createType(
 
   const get = () => {
     if (isOptional) {
-      const wrapping = createType(language, type, false)
+      const wrapping = createType(language, type, false, typeNode)
       return new OptionalType(wrapping)
     }
 
@@ -286,10 +339,10 @@ export function createType(
       // - of string literals (then it's an enum)
       // - of type `T | undefined` (then it's just optional `T`)
       // - of different types (then it's a variant `A | B | C`)
-      const types = type.getUnionTypes()
-      const nonNullTypes = types.filter(
-        (t) => !t.isNull() && !t.isUndefined() && !t.isVoid()
-      )
+      const unionConstituents = getUnionConstituents(type, typeNode)
+      const nonNullTypes = unionConstituents
+        .map((c) => c.type)
+        .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid())
       const isEnumUnion = nonNullTypes.every((t) => t.isStringLiteral())
       if (isEnumUnion) {
         // It consists only of string literaly - that means it's describing an enum!
@@ -305,11 +358,12 @@ export function createType(
         return new EnumType(typename, type)
       } else {
         // It consists of different types - that means it's a variant!
-        let variants = type
-          .getUnionTypes()
+        let variants = unionConstituents
           // Filter out any undefineds/voids, as those are already treated as `isOptional`.
-          .filter((t) => !t.isUndefined() && !t.isVoid())
-          .map((t) => createType(language, t, false))
+          .filter(({ type: t }) => !t.isUndefined() && !t.isVoid())
+          .map(({ type: t, typeNode: node }) =>
+            createType(language, t, false, node)
+          )
           .toSorted(compareLooselyness)
         variants = removeDuplicates(variants)
 
diff --git a/packages/nitrogen/src/syntax/getInterfaceProperties.ts b/packages/nitrogen/src/syntax/getInterfaceProperties.ts
index da99081caa..e1f2702828 100644
--- a/packages/nitrogen/src/syntax/getInterfaceProperties.ts
+++ b/packages/nitrogen/src/syntax/getInterfaceProperties.ts
@@ -1,4 +1,4 @@
-import type { ts, Type } from 'ts-morph'
+import { Node, type ts, type Type } from 'ts-morph'
 import type { NamedType } from './types/Type.js'
 import { createNamedType } from './createType.js'
 import type { Language } from '../getPlatformSpecs.js'
@@ -13,6 +13,9 @@ export function getInterfaceProperties(
       `Interface "${interfaceType.getText()}" does not have a Symbol!`
     )
   return interfaceType.getProperties().map((prop) => {
+    const propDeclaration = prop
+      .getDeclarations()
+      .find((declaration) => Node.isPropertySignature(declaration))
     let propType = prop.getDeclaredType()
     if (propType.isAny() || propType.isUnknown()) {
       // the interface is aliased/merged - we need to look into the actual declaration
@@ -29,7 +32,8 @@ export function getInterfaceProperties(
       language,
       prop.getName(),
       propType,
-      prop.isOptional() || propType.isNullable()
+      prop.isOptional() || propType.isNullable(),
+      propDeclaration?.getTypeNode()
     )
     return refType
   })
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 1493d59adb..3b09475ed0 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
@@ -30,7 +30,7 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
   override var optionalHybrid: HybridTestObjectSwiftKotlinSpec? = null
   override val thisObject: HybridTestObjectSwiftKotlinSpec
     get() = this
-  override var someVariant: Variant_String_Double = Variant_String_Double.create(55.05)
+  override var someVariant: Variant_Double_String = Variant_Double_String.create(55.05)
   override var optionalArray: Array<String>? = null
   override var optionalEnum: Powertrain? = null
   override var optionalOldEnum: OldEnum? = null
@@ -497,13 +497,13 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
     return Promise.async { createArrayBuffer() }
   }
 
-  override fun passVariant(either: Variant_Boolean_DoubleArray_Array_String__String_Double): Variant_String_Double {
+  override fun passVariant(either: Variant_Boolean_DoubleArray_Array_String__Double_String): Variant_Double_String {
     return either.match(
-      { bool -> Variant_String_Double.create("holds something else!") },
-      { doubleArray -> Variant_String_Double.create("holds something else!") },
-      { stringArray -> Variant_String_Double.create("holds something else!") },
-      { string -> Variant_String_Double.create(string) },
-      { double -> Variant_String_Double.create(double) },
+      { bool -> Variant_Double_String.create("holds something else!") },
+      { doubleArray -> Variant_Double_String.create("holds something else!") },
+      { stringArray -> Variant_Double_String.create("holds something else!") },
+      { double -> Variant_Double_String.create(double) },
+      { string -> Variant_Double_String.create(string) },
     )
   }
 
@@ -515,15 +515,19 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
     return variant
   }
 
-  override fun getVariantEnum(variant: Variant_Boolean_OldEnum): Variant_Boolean_OldEnum {
+  override fun getVariantEnum(variant: Variant_OldEnum_Boolean): Variant_OldEnum_Boolean {
     return variant
   }
 
-  override fun getVariantWeirdNumbersEnum(variant: Variant_Boolean_WeirdNumbersEnum): Variant_Boolean_WeirdNumbersEnum {
+  override fun bounceVariantUnionEnum(variant: Variant_Powertrain_Car): Variant_Powertrain_Car {
     return variant
   }
 
-  override fun getVariantObjects(variant: Variant_Car_Person): Variant_Car_Person {
+  override fun getVariantWeirdNumbersEnum(variant: Variant_WeirdNumbersEnum_Boolean): Variant_WeirdNumbersEnum_Boolean {
+    return variant
+  }
+
+  override fun getVariantObjects(variant: Variant_Person_Car): Variant_Person_Car {
     return variant
   }
 
diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp
index 8703852765..ca40490f55 100644
--- a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp
+++ b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp
@@ -107,11 +107,11 @@ void HybridTestObjectCpp::setOptionalHybrid(const std::optional<std::shared_ptr<
   _optionalHybrid = optionalHybrid;
 }
 
-std::variant<std::string, double> HybridTestObjectCpp::getSomeVariant() {
+std::variant<double, std::string> HybridTestObjectCpp::getSomeVariant() {
   return _variant;
 }
 
-void HybridTestObjectCpp::setSomeVariant(const std::variant<std::string, double>& variant) {
+void HybridTestObjectCpp::setSomeVariant(const std::variant<double, std::string>& variant) {
   _variant = variant;
 }
 
@@ -366,8 +366,8 @@ std::chrono::system_clock::time_point HybridTestObjectCpp::currentDate() {
   return std::chrono::system_clock::now();
 }
 
-std::variant<std::string, double>
-HybridTestObjectCpp::passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& either) {
+std::variant<double, std::string>
+HybridTestObjectCpp::passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& either) {
   if (std::holds_alternative<std::string>(either)) {
     return std::get<std::string>(either);
   } else if (std::holds_alternative<double>(either)) {
@@ -386,15 +386,19 @@ ComplexVariant HybridTestObjectCpp::bounceComplexVariant(const ComplexVariant& v
   return variant;
 }
 
-std::variant<bool, OldEnum> HybridTestObjectCpp::getVariantEnum(const std::variant<bool, OldEnum>& variant) {
+std::variant<OldEnum, bool> HybridTestObjectCpp::getVariantEnum(const std::variant<OldEnum, bool>& variant) {
   return variant;
 }
 
-std::variant<bool, WeirdNumbersEnum> HybridTestObjectCpp::getVariantWeirdNumbersEnum(const std::variant<bool, WeirdNumbersEnum>& variant) {
+std::variant<Powertrain, Car> HybridTestObjectCpp::bounceVariantUnionEnum(const std::variant<Powertrain, Car>& variant) {
   return variant;
 }
 
-std::variant<Car, Person> HybridTestObjectCpp::getVariantObjects(const std::variant<Car, Person>& variant) {
+std::variant<WeirdNumbersEnum, bool> HybridTestObjectCpp::getVariantWeirdNumbersEnum(const std::variant<WeirdNumbersEnum, bool>& variant) {
+  return variant;
+}
+
+std::variant<Person, Car> HybridTestObjectCpp::getVariantObjects(const std::variant<Person, Car>& variant) {
   return variant;
 }
 
@@ -403,6 +407,11 @@ HybridTestObjectCpp::getVariantHybrid(const std::variant<std::shared_ptr<HybridT
   return variant;
 }
 
+std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Powertrain>
+HybridTestObjectCpp::getVariantHybridEnum(const std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Powertrain>& variant) {
+  return variant;
+}
+
 std::variant<std::tuple<double, double>, std::tuple<double, double, double>>
 HybridTestObjectCpp::getVariantTuple(const std::variant<std::tuple<double, double>, std::tuple<double, double, double>>& variant) {
   return variant;
diff --git a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp
index 9e17c74fa9..38df758f8f 100644
--- a/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp
+++ b/packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp
@@ -32,7 +32,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   NullType _null = nitro::null;
   std::optional<std::string> _optionalString;
   std::variant<nitro::NullType, std::string> _nullableString;
-  std::variant<std::string, double> _variant;
+  std::variant<double, std::string> _variant;
   std::tuple<double, std::string> _tuple;
   std::optional<std::vector<std::string>> _optionalArray;
   std::optional<std::shared_ptr<HybridTestObjectCppSpec>> _optionalHybrid;
@@ -74,8 +74,8 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   void setStringOrNull(const std::variant<nitro::NullType, std::string>& stringOrNull) override;
   std::optional<std::vector<std::string>> getOptionalArray() override;
   void setOptionalArray(const std::optional<std::vector<std::string>>& optionalArray) override;
-  std::variant<std::string, double> getSomeVariant() override;
-  void setSomeVariant(const std::variant<std::string, double>& variant) override;
+  std::variant<double, std::string> getSomeVariant() override;
+  void setSomeVariant(const std::variant<double, std::string>& variant) override;
   std::variant<std::string, Car> passNamedVariant(const std::variant<std::string, Car>& variant) override;
   std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper>
   passAllEmptyObjectVariant(const std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper>& variant) override;
@@ -121,8 +121,8 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   bool tryTrailingOptional(double num, const std::string& str, std::optional<bool> boo) override;
   std::chrono::system_clock::time_point add1Hour(std::chrono::system_clock::time_point date) override;
   std::chrono::system_clock::time_point currentDate() override;
-  std::variant<std::string, double>
-  passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& either) override;
+  std::variant<double, std::string>
+  passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& either) override;
 
   std::vector<std::string> bounceStrings(const std::vector<std::string>& array) override;
   std::vector<double> bounceNumbers(const std::vector<double>& array) override;
@@ -140,11 +140,14 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   std::vector<std::shared_ptr<Promise<double>>> bouncePromises(const std::vector<std::shared_ptr<Promise<double>>>& promises) override;
   std::vector<std::shared_ptr<ArrayBuffer>> bounceArrayBuffers(const std::vector<std::shared_ptr<ArrayBuffer>>& arrayBuffers) override;
 
-  std::variant<bool, OldEnum> getVariantEnum(const std::variant<bool, OldEnum>& variant) override;
-  std::variant<bool, WeirdNumbersEnum> getVariantWeirdNumbersEnum(const std::variant<bool, WeirdNumbersEnum>& variant) override;
-  std::variant<Car, Person> getVariantObjects(const std::variant<Car, Person>& variant) override;
+  std::variant<OldEnum, bool> getVariantEnum(const std::variant<OldEnum, bool>& variant) override;
+  std::variant<Powertrain, Car> bounceVariantUnionEnum(const std::variant<Powertrain, Car>& variant) override;
+  std::variant<WeirdNumbersEnum, bool> getVariantWeirdNumbersEnum(const std::variant<WeirdNumbersEnum, bool>& variant) override;
+  std::variant<Person, Car> getVariantObjects(const std::variant<Person, Car>& variant) override;
   std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Person>
   getVariantHybrid(const std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Person>& variant) override;
+  std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Powertrain>
+  getVariantHybridEnum(const std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Powertrain>& variant) override;
   std::variant<std::tuple<double, double>, std::tuple<double, double, double>>
   getVariantTuple(const std::variant<std::tuple<double, double>, std::tuple<double, double, double>>& variant) override;
 
diff --git a/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift b/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift
index fe66e5f2b9..d30704961e 100644
--- a/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift
+++ b/packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift
@@ -11,7 +11,7 @@ import NitroTestExternal
 class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
   var optionalArray: [String]? = []
 
-  var someVariant: Variant_String_Double = .second(55)
+  var someVariant: Variant_Double_String = .first(55)
 
   var numberValue: Double = 0.0
 
@@ -338,16 +338,16 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
     return variant
   }
 
-  func passVariant(either: Variant_Bool__Double___String__String_Double) throws
-    -> Variant_String_Double
+  func passVariant(either: Variant_Bool__Double___String__Double_String) throws
+    -> Variant_Double_String
   {
     switch either {
-    case .fourth(let string):
-      return .first(string)
-    case .fifth(let double):
-      return .second(double)
+    case .fourth(let double):
+      return .first(double)
+    case .fifth(let string):
+      return .second(string)
     default:
-      return .first("holds something else!")
+      return .second("holds something else!")
     }
   }
 
@@ -361,17 +361,21 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
     return variant
   }
 
-  func getVariantEnum(variant: Variant_Bool_OldEnum) throws -> Variant_Bool_OldEnum {
+  func getVariantEnum(variant: Variant_OldEnum_Bool) throws -> Variant_OldEnum_Bool {
     return variant
   }
 
-  func getVariantWeirdNumbersEnum(variant: Variant_Bool_WeirdNumbersEnum) throws
-    -> Variant_Bool_WeirdNumbersEnum
+  func bounceVariantUnionEnum(variant: Variant_Powertrain_Car) throws -> Variant_Powertrain_Car {
+    return variant
+  }
+
+  func getVariantWeirdNumbersEnum(variant: Variant_WeirdNumbersEnum_Bool) throws
+    -> Variant_WeirdNumbersEnum_Bool
   {
     return variant
   }
 
-  func getVariantObjects(variant: Variant_Car_Person) throws -> Variant_Car_Person {
+  func getVariantObjects(variant: Variant_Person_Car) throws -> Variant_Person_Car {
     return variant
   }
 
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake b/packages/react-native-nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake
index 453148d1b5..222b2ef3fe 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/NitroTest+autolinking.cmake
@@ -46,7 +46,7 @@ target_sources(
   ../nitrogen/generated/android/c++/JHybridBaseSpec.cpp
   ../nitrogen/generated/android/c++/JHybridChildSpec.cpp
   ../nitrogen/generated/android/c++/JNamedVariant.cpp
-  ../nitrogen/generated/android/c++/JVariant_String_Double.cpp
+  ../nitrogen/generated/android/c++/JVariant_Double_String.cpp
   ../nitrogen/generated/android/c++/JHybridPlatformObjectSpec.cpp
   ../nitrogen/generated/android/c++/JHybridRecyclableTestViewSpec.cpp
   ../nitrogen/generated/android/c++/views/JHybridRecyclableTestViewStateUpdater.cpp
@@ -55,13 +55,14 @@ target_sources(
   ../nitrogen/generated/android/c++/JVariant_HybridTestObjectSwiftKotlinSpec_Person.cpp
   ../nitrogen/generated/android/c++/JVariant_Boolean_Double.cpp
   ../nitrogen/generated/android/c++/JVariant_______Unit_Double.cpp
-  ../nitrogen/generated/android/c++/JVariant_Boolean_OldEnum.cpp
-  ../nitrogen/generated/android/c++/JVariant_Boolean_WeirdNumbersEnum.cpp
-  ../nitrogen/generated/android/c++/JVariant_Car_Person.cpp
+  ../nitrogen/generated/android/c++/JVariant_OldEnum_Boolean.cpp
+  ../nitrogen/generated/android/c++/JVariant_Powertrain_Car.cpp
+  ../nitrogen/generated/android/c++/JVariant_WeirdNumbersEnum_Boolean.cpp
+  ../nitrogen/generated/android/c++/JVariant_Person_Car.cpp
   ../nitrogen/generated/android/c++/JVariant_HybridBaseSpec_OptionalWrapper.cpp
   ../nitrogen/generated/android/c++/JCoreTypesVariant.cpp
   ../nitrogen/generated/android/c++/JStringOrExternal.cpp
-  ../nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__String_Double.cpp
+  ../nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__Double_String.cpp
   ../nitrogen/generated/android/c++/JHybridTestViewSpec.cpp
   ../nitrogen/generated/android/c++/views/JHybridTestViewStateUpdater.cpp
 )
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JCar.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JCar.hpp
index e9c2d17daa..2c6d108f2e 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JCar.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JCar.hpp
@@ -12,7 +12,7 @@
 
 #include "JPerson.hpp"
 #include "JPowertrain.hpp"
-#include "JVariant_String_Double.hpp"
+#include "JVariant_Double_String.hpp"
 #include "Person.hpp"
 #include "Powertrain.hpp"
 #include <optional>
@@ -59,8 +59,8 @@ namespace margelo::nitro::test {
       jni::local_ref<jni::JString> favouriteTrack = this->getFieldValue(fieldFavouriteTrack);
       static const auto fieldPerformanceScores = clazz->getField<jni::JArrayDouble>("performanceScores");
       jni::local_ref<jni::JArrayDouble> performanceScores = this->getFieldValue(fieldPerformanceScores);
-      static const auto fieldSomeVariant = clazz->getField<JVariant_String_Double>("someVariant");
-      jni::local_ref<JVariant_String_Double> someVariant = this->getFieldValue(fieldSomeVariant);
+      static const auto fieldSomeVariant = clazz->getField<JVariant_Double_String>("someVariant");
+      jni::local_ref<JVariant_Double_String> someVariant = this->getFieldValue(fieldSomeVariant);
       return Car(
         year,
         make->toStdString(),
@@ -96,7 +96,7 @@ namespace margelo::nitro::test {
      */
     [[maybe_unused]]
     static jni::local_ref<JCar::javaobject> fromCpp(const Car& value) {
-      using JSignature = JCar(double, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, double, jni::alias_ref<JPowertrain>, jni::alias_ref<JPerson>, jni::alias_ref<jni::JArrayClass<JPerson>>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JArrayDouble>, jni::alias_ref<JVariant_String_Double>);
+      using JSignature = JCar(double, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, double, jni::alias_ref<JPowertrain>, jni::alias_ref<JPerson>, jni::alias_ref<jni::JArrayClass<JPerson>>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JArrayDouble>, jni::alias_ref<JVariant_Double_String>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -125,7 +125,7 @@ namespace margelo::nitro::test {
           __array->setRegion(0, __size, value.performanceScores.data());
           return __array;
         }(),
-        value.someVariant.has_value() ? JVariant_String_Double::fromCpp(value.someVariant.value()) : nullptr
+        value.someVariant.has_value() ? JVariant_Double_String::fromCpp(value.someVariant.value()) : nullptr
       );
     }
   };
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridChildSpec.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridChildSpec.cpp
index f7178b5203..a04c01e63d 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridChildSpec.cpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridChildSpec.cpp
@@ -25,7 +25,7 @@ namespace margelo::nitro::test { struct Person; }
 #include <optional>
 #include "JPerson.hpp"
 #include <vector>
-#include "JVariant_String_Double.hpp"
+#include "JVariant_Double_String.hpp"
 
 namespace margelo::nitro::test {
 
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 dafb2f458b..3f55e8106a 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
@@ -63,7 +63,7 @@ namespace margelo::nitro::test { class HybridTestViewSpec; }
 #include <functional>
 #include "JFunc_void_double.hpp"
 #include <NitroModules/JNICallable.hpp>
-#include "JVariant_String_Double.hpp"
+#include "JVariant_Double_String.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "Person.hpp"
@@ -96,11 +96,12 @@ namespace margelo::nitro::test { class HybridTestViewSpec; }
 #include "JVariant_______Unit_Double.hpp"
 #include "OptionalEnumWrapper.hpp"
 #include "JOptionalEnumWrapper.hpp"
-#include "JVariant_Boolean_OldEnum.hpp"
+#include "JVariant_OldEnum_Boolean.hpp"
+#include "JVariant_Powertrain_Car.hpp"
 #include "WeirdNumbersEnum.hpp"
-#include "JVariant_Boolean_WeirdNumbersEnum.hpp"
+#include "JVariant_WeirdNumbersEnum_Boolean.hpp"
 #include "JWeirdNumbersEnum.hpp"
-#include "JVariant_Car_Person.hpp"
+#include "JVariant_Person_Car.hpp"
 #include "JNamedVariant.hpp"
 #include "HybridBaseSpec.hpp"
 #include "JVariant_HybridBaseSpec_OptionalWrapper.hpp"
@@ -125,7 +126,7 @@ 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 "JVariant_Boolean_DoubleArray_Array_String__String_Double.hpp"
+#include "JVariant_Boolean_DoubleArray_Array_String__Double_String.hpp"
 #include "JFunc_double.hpp"
 #include "HybridTestViewSpec.hpp"
 #include "JHybridTestViewSpec.hpp"
@@ -346,14 +347,14 @@ namespace margelo::nitro::test {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* isBooleanWritable */)>("setBooleanWritable");
     method(_javaPart, isBooleanWritable);
   }
-  std::variant<std::string, double> JHybridTestObjectSwiftKotlinSpec::getSomeVariant() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_String_Double>()>("getSomeVariant");
+  std::variant<double, std::string> JHybridTestObjectSwiftKotlinSpec::getSomeVariant() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_Double_String>()>("getSomeVariant");
     auto __result = method(_javaPart);
     return __result->toCpp();
   }
-  void JHybridTestObjectSwiftKotlinSpec::setSomeVariant(const std::variant<std::string, double>& someVariant) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JVariant_String_Double> /* someVariant */)>("setSomeVariant");
-    method(_javaPart, JVariant_String_Double::fromCpp(someVariant));
+  void JHybridTestObjectSwiftKotlinSpec::setSomeVariant(const std::variant<double, std::string>& someVariant) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JVariant_Double_String> /* someVariant */)>("setSomeVariant");
+    method(_javaPart, JVariant_Double_String::fromCpp(someVariant));
   }
 
   // Methods
@@ -1272,24 +1273,29 @@ namespace margelo::nitro::test {
     auto __result = method(_javaPart, JArrayBuffer::wrap(buffer));
     return __result->cthis()->getArrayBuffer();
   }
-  std::variant<std::string, double> JHybridTestObjectSwiftKotlinSpec::passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& either) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_String_Double>(jni::alias_ref<JVariant_Boolean_DoubleArray_Array_String__String_Double> /* either */)>("passVariant");
-    auto __result = method(_javaPart, JVariant_Boolean_DoubleArray_Array_String__String_Double::fromCpp(either));
+  std::variant<double, std::string> JHybridTestObjectSwiftKotlinSpec::passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& either) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_Double_String>(jni::alias_ref<JVariant_Boolean_DoubleArray_Array_String__Double_String> /* either */)>("passVariant");
+    auto __result = method(_javaPart, JVariant_Boolean_DoubleArray_Array_String__Double_String::fromCpp(either));
     return __result->toCpp();
   }
-  std::variant<bool, OldEnum> JHybridTestObjectSwiftKotlinSpec::getVariantEnum(const std::variant<bool, OldEnum>& variant) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_Boolean_OldEnum>(jni::alias_ref<JVariant_Boolean_OldEnum> /* variant */)>("getVariantEnum");
-    auto __result = method(_javaPart, JVariant_Boolean_OldEnum::fromCpp(variant));
+  std::variant<OldEnum, bool> JHybridTestObjectSwiftKotlinSpec::getVariantEnum(const std::variant<OldEnum, bool>& variant) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_OldEnum_Boolean>(jni::alias_ref<JVariant_OldEnum_Boolean> /* variant */)>("getVariantEnum");
+    auto __result = method(_javaPart, JVariant_OldEnum_Boolean::fromCpp(variant));
     return __result->toCpp();
   }
-  std::variant<bool, WeirdNumbersEnum> JHybridTestObjectSwiftKotlinSpec::getVariantWeirdNumbersEnum(const std::variant<bool, WeirdNumbersEnum>& variant) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_Boolean_WeirdNumbersEnum>(jni::alias_ref<JVariant_Boolean_WeirdNumbersEnum> /* variant */)>("getVariantWeirdNumbersEnum");
-    auto __result = method(_javaPart, JVariant_Boolean_WeirdNumbersEnum::fromCpp(variant));
+  std::variant<Powertrain, Car> JHybridTestObjectSwiftKotlinSpec::bounceVariantUnionEnum(const std::variant<Powertrain, Car>& variant) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_Powertrain_Car>(jni::alias_ref<JVariant_Powertrain_Car> /* variant */)>("bounceVariantUnionEnum");
+    auto __result = method(_javaPart, JVariant_Powertrain_Car::fromCpp(variant));
     return __result->toCpp();
   }
-  std::variant<Car, Person> JHybridTestObjectSwiftKotlinSpec::getVariantObjects(const std::variant<Car, Person>& variant) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_Car_Person>(jni::alias_ref<JVariant_Car_Person> /* variant */)>("getVariantObjects");
-    auto __result = method(_javaPart, JVariant_Car_Person::fromCpp(variant));
+  std::variant<WeirdNumbersEnum, bool> JHybridTestObjectSwiftKotlinSpec::getVariantWeirdNumbersEnum(const std::variant<WeirdNumbersEnum, bool>& variant) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_WeirdNumbersEnum_Boolean>(jni::alias_ref<JVariant_WeirdNumbersEnum_Boolean> /* variant */)>("getVariantWeirdNumbersEnum");
+    auto __result = method(_javaPart, JVariant_WeirdNumbersEnum_Boolean::fromCpp(variant));
+    return __result->toCpp();
+  }
+  std::variant<Person, Car> JHybridTestObjectSwiftKotlinSpec::getVariantObjects(const std::variant<Person, Car>& variant) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_Person_Car>(jni::alias_ref<JVariant_Person_Car> /* variant */)>("getVariantObjects");
+    auto __result = method(_javaPart, JVariant_Person_Car::fromCpp(variant));
     return __result->toCpp();
   }
   std::variant<std::string, Car> JHybridTestObjectSwiftKotlinSpec::passNamedVariant(const std::variant<std::string, Car>& variant) {
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 de03552731..a7c1ff18dd 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
@@ -85,8 +85,8 @@ namespace margelo::nitro::test {
     void setHasBooleanWritable(bool hasBooleanWritable) override;
     bool getIsBooleanWritable() override;
     void setIsBooleanWritable(bool isBooleanWritable) override;
-    std::variant<std::string, double> getSomeVariant() override;
-    void setSomeVariant(const std::variant<std::string, double>& someVariant) override;
+    std::variant<double, std::string> getSomeVariant() override;
+    void setSomeVariant(const std::variant<double, std::string>& someVariant) override;
 
   public:
     // Methods
@@ -169,10 +169,11 @@ namespace margelo::nitro::test {
     void setAllValuesTo(const std::shared_ptr<ArrayBuffer>& buffer, double value) override;
     std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> createArrayBufferAsync() override;
     std::shared_ptr<ArrayBuffer> bounceArrayBuffer(const std::shared_ptr<ArrayBuffer>& buffer) override;
-    std::variant<std::string, double> passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& either) override;
-    std::variant<bool, OldEnum> getVariantEnum(const std::variant<bool, OldEnum>& variant) override;
-    std::variant<bool, WeirdNumbersEnum> getVariantWeirdNumbersEnum(const std::variant<bool, WeirdNumbersEnum>& variant) override;
-    std::variant<Car, Person> getVariantObjects(const std::variant<Car, Person>& variant) override;
+    std::variant<double, std::string> passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& either) override;
+    std::variant<OldEnum, bool> getVariantEnum(const std::variant<OldEnum, bool>& variant) override;
+    std::variant<Powertrain, Car> bounceVariantUnionEnum(const std::variant<Powertrain, Car>& variant) override;
+    std::variant<WeirdNumbersEnum, bool> getVariantWeirdNumbersEnum(const std::variant<WeirdNumbersEnum, bool>& variant) override;
+    std::variant<Person, Car> getVariantObjects(const std::variant<Person, Car>& variant) override;
     std::variant<std::string, Car> passNamedVariant(const std::variant<std::string, Car>& variant) override;
     std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper> passAllEmptyObjectVariant(const std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper>& variant) override;
     std::variant<std::shared_ptr<ArrayBuffer>, std::function<void(double /* value */)>, WrappedJsStruct, std::shared_ptr<Promise<double>>, std::chrono::system_clock::time_point, std::shared_ptr<AnyMap>> bounceComplexVariant(const std::variant<std::shared_ptr<ArrayBuffer>, std::function<void(double /* value */)>, WrappedJsStruct, std::shared_ptr<Promise<double>>, std::chrono::system_clock::time_point, std::shared_ptr<AnyMap>>& variant) override;
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JNamedVariant.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JNamedVariant.hpp
index e763f29f84..938b757860 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JNamedVariant.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JNamedVariant.hpp
@@ -20,7 +20,7 @@
 #include <optional>
 #include "JPerson.hpp"
 #include <vector>
-#include "JVariant_String_Double.hpp"
+#include "JVariant_Double_String.hpp"
 
 namespace margelo::nitro::test {
 
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__String_Double.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__Double_String.cpp
similarity index 65%
rename from packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__String_Double.cpp
rename to packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__Double_String.cpp
index 1921297889..829492384f 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__String_Double.cpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__Double_String.cpp
@@ -1,33 +1,33 @@
 ///
-/// JVariant_Boolean_DoubleArray_Array_String__String_Double.cpp
+/// JVariant_Boolean_DoubleArray_Array_String__Double_String.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
-#include "JVariant_Boolean_DoubleArray_Array_String__String_Double.hpp"
+#include "JVariant_Boolean_DoubleArray_Array_String__Double_String.hpp"
 
 namespace margelo::nitro::test {
   /**
-   * Converts JVariant_Boolean_DoubleArray_Array_String__String_Double to std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>
+   * Converts JVariant_Boolean_DoubleArray_Array_String__Double_String to std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>
    */
-  std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double> JVariant_Boolean_DoubleArray_Array_String__String_Double::toCpp() const {
-    if (isInstanceOf(JVariant_Boolean_DoubleArray_Array_String__String_Double_impl::First::javaClassStatic())) {
+  std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string> JVariant_Boolean_DoubleArray_Array_String__Double_String::toCpp() const {
+    if (isInstanceOf(JVariant_Boolean_DoubleArray_Array_String__Double_String_impl::First::javaClassStatic())) {
       // It's a `bool`
-      auto jniValue = static_cast<const JVariant_Boolean_DoubleArray_Array_String__String_Double_impl::First*>(this)->getValue();
+      auto jniValue = static_cast<const JVariant_Boolean_DoubleArray_Array_String__Double_String_impl::First*>(this)->getValue();
       return static_cast<bool>(jniValue);
-    } else if (isInstanceOf(JVariant_Boolean_DoubleArray_Array_String__String_Double_impl::Second::javaClassStatic())) {
+    } else if (isInstanceOf(JVariant_Boolean_DoubleArray_Array_String__Double_String_impl::Second::javaClassStatic())) {
       // It's a `std::vector<double>`
-      auto jniValue = static_cast<const JVariant_Boolean_DoubleArray_Array_String__String_Double_impl::Second*>(this)->getValue();
+      auto jniValue = static_cast<const JVariant_Boolean_DoubleArray_Array_String__Double_String_impl::Second*>(this)->getValue();
       return [&]() {
         size_t __size = jniValue->size();
         std::vector<double> __vector(__size);
         jniValue->getRegion(0, __size, __vector.data());
         return __vector;
       }();
-    } else if (isInstanceOf(JVariant_Boolean_DoubleArray_Array_String__String_Double_impl::Third::javaClassStatic())) {
+    } else if (isInstanceOf(JVariant_Boolean_DoubleArray_Array_String__Double_String_impl::Third::javaClassStatic())) {
       // It's a `std::vector<std::string>`
-      auto jniValue = static_cast<const JVariant_Boolean_DoubleArray_Array_String__String_Double_impl::Third*>(this)->getValue();
+      auto jniValue = static_cast<const JVariant_Boolean_DoubleArray_Array_String__Double_String_impl::Third*>(this)->getValue();
       return [&](auto&& __input) {
         size_t __size = __input->size();
         std::vector<std::string> __vector;
@@ -38,14 +38,14 @@ namespace margelo::nitro::test {
         }
         return __vector;
       }(jniValue);
-    } else if (isInstanceOf(JVariant_Boolean_DoubleArray_Array_String__String_Double_impl::Fourth::javaClassStatic())) {
-      // It's a `std::string`
-      auto jniValue = static_cast<const JVariant_Boolean_DoubleArray_Array_String__String_Double_impl::Fourth*>(this)->getValue();
-      return jniValue->toStdString();
-    } else if (isInstanceOf(JVariant_Boolean_DoubleArray_Array_String__String_Double_impl::Fifth::javaClassStatic())) {
+    } else if (isInstanceOf(JVariant_Boolean_DoubleArray_Array_String__Double_String_impl::Fourth::javaClassStatic())) {
       // It's a `double`
-      auto jniValue = static_cast<const JVariant_Boolean_DoubleArray_Array_String__String_Double_impl::Fifth*>(this)->getValue();
+      auto jniValue = static_cast<const JVariant_Boolean_DoubleArray_Array_String__Double_String_impl::Fourth*>(this)->getValue();
       return jniValue;
+    } else if (isInstanceOf(JVariant_Boolean_DoubleArray_Array_String__Double_String_impl::Fifth::javaClassStatic())) {
+      // It's a `std::string`
+      auto jniValue = static_cast<const JVariant_Boolean_DoubleArray_Array_String__Double_String_impl::Fifth*>(this)->getValue();
+      return jniValue->toStdString();
     }
     throw std::invalid_argument("Variant is unknown Kotlin instance!");
   }
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__String_Double.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__Double_String.hpp
similarity index 71%
rename from packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__String_Double.hpp
rename to packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__Double_String.hpp
index a931fe8799..e57c16773c 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__String_Double.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_DoubleArray_Array_String__Double_String.hpp
@@ -1,5 +1,5 @@
 ///
-/// JVariant_Boolean_DoubleArray_Array_String__String_Double.hpp
+/// JVariant_Boolean_DoubleArray_Array_String__Double_String.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -19,34 +19,34 @@ namespace margelo::nitro::test {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_Boolean_DoubleArray_Array_String__String_Double".
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_Boolean_DoubleArray_Array_String__Double_String".
    */
-  class JVariant_Boolean_DoubleArray_Array_String__String_Double: public jni::JavaClass<JVariant_Boolean_DoubleArray_Array_String__String_Double> {
+  class JVariant_Boolean_DoubleArray_Array_String__Double_String: public jni::JavaClass<JVariant_Boolean_DoubleArray_Array_String__Double_String> {
   public:
-    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__String_Double;";
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__Double_String;";
 
-    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__String_Double> create_0(jboolean value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_DoubleArray_Array_String__String_Double(jboolean)>("create");
+    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__Double_String> create_0(jboolean value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_DoubleArray_Array_String__Double_String(jboolean)>("create");
       return method(javaClassStatic(), value);
     }
-    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__String_Double> create_1(jni::alias_ref<jni::JArrayDouble> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_DoubleArray_Array_String__String_Double(jni::alias_ref<jni::JArrayDouble>)>("create");
+    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__Double_String> create_1(jni::alias_ref<jni::JArrayDouble> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_DoubleArray_Array_String__Double_String(jni::alias_ref<jni::JArrayDouble>)>("create");
       return method(javaClassStatic(), value);
     }
-    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__String_Double> create_2(jni::alias_ref<jni::JArrayClass<jni::JString>> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_DoubleArray_Array_String__String_Double(jni::alias_ref<jni::JArrayClass<jni::JString>>)>("create");
+    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__Double_String> create_2(jni::alias_ref<jni::JArrayClass<jni::JString>> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_DoubleArray_Array_String__Double_String(jni::alias_ref<jni::JArrayClass<jni::JString>>)>("create");
       return method(javaClassStatic(), value);
     }
-    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__String_Double> create_3(jni::alias_ref<jni::JString> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_DoubleArray_Array_String__String_Double(jni::alias_ref<jni::JString>)>("create");
+    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__Double_String> create_3(double value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_DoubleArray_Array_String__Double_String(double)>("create");
       return method(javaClassStatic(), value);
     }
-    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__String_Double> create_4(double value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_DoubleArray_Array_String__String_Double(double)>("create");
+    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__Double_String> create_4(jni::alias_ref<jni::JString> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_DoubleArray_Array_String__Double_String(jni::alias_ref<jni::JString>)>("create");
       return method(javaClassStatic(), value);
     }
 
-    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__String_Double> fromCpp(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& variant) {
+    static jni::local_ref<JVariant_Boolean_DoubleArray_Array_String__Double_String> fromCpp(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& variant) {
       switch (variant.index()) {
         case 0: return create_0(std::get<0>(variant));
         case 1: return create_1([&]() {
@@ -65,19 +65,19 @@ namespace margelo::nitro::test {
           }
           return __array;
         }(std::get<2>(variant)));
-        case 3: return create_3(jni::make_jstring(std::get<3>(variant)));
-        case 4: return create_4(std::get<4>(variant));
+        case 3: return create_3(std::get<3>(variant));
+        case 4: return create_4(jni::make_jstring(std::get<4>(variant)));
         default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
       }
     }
 
-    [[nodiscard]] std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double> toCpp() const;
+    [[nodiscard]] std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string> toCpp() const;
   };
 
-  namespace JVariant_Boolean_DoubleArray_Array_String__String_Double_impl {
-    class First final: public jni::JavaClass<First, JVariant_Boolean_DoubleArray_Array_String__String_Double> {
+  namespace JVariant_Boolean_DoubleArray_Array_String__Double_String_impl {
+    class First final: public jni::JavaClass<First, JVariant_Boolean_DoubleArray_Array_String__Double_String> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__String_Double$First;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__Double_String$First;";
     
       [[nodiscard]] jboolean getValue() const {
         static const auto field = javaClassStatic()->getField<jboolean>("value");
@@ -85,9 +85,9 @@ namespace margelo::nitro::test {
       }
     };
     
-    class Second final: public jni::JavaClass<Second, JVariant_Boolean_DoubleArray_Array_String__String_Double> {
+    class Second final: public jni::JavaClass<Second, JVariant_Boolean_DoubleArray_Array_String__Double_String> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__String_Double$Second;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__Double_String$Second;";
     
       [[nodiscard]] jni::local_ref<jni::JArrayDouble> getValue() const {
         static const auto field = javaClassStatic()->getField<jni::JArrayDouble>("value");
@@ -95,9 +95,9 @@ namespace margelo::nitro::test {
       }
     };
     
-    class Third final: public jni::JavaClass<Third, JVariant_Boolean_DoubleArray_Array_String__String_Double> {
+    class Third final: public jni::JavaClass<Third, JVariant_Boolean_DoubleArray_Array_String__Double_String> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__String_Double$Third;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__Double_String$Third;";
     
       [[nodiscard]] jni::local_ref<jni::JArrayClass<jni::JString>> getValue() const {
         static const auto field = javaClassStatic()->getField<jni::JArrayClass<jni::JString>>("value");
@@ -105,24 +105,24 @@ namespace margelo::nitro::test {
       }
     };
     
-    class Fourth final: public jni::JavaClass<Fourth, JVariant_Boolean_DoubleArray_Array_String__String_Double> {
+    class Fourth final: public jni::JavaClass<Fourth, JVariant_Boolean_DoubleArray_Array_String__Double_String> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__String_Double$Fourth;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__Double_String$Fourth;";
     
-      [[nodiscard]] jni::local_ref<jni::JString> getValue() const {
-        static const auto field = javaClassStatic()->getField<jni::JString>("value");
+      [[nodiscard]] double getValue() const {
+        static const auto field = javaClassStatic()->getField<double>("value");
         return getFieldValue(field);
       }
     };
     
-    class Fifth final: public jni::JavaClass<Fifth, JVariant_Boolean_DoubleArray_Array_String__String_Double> {
+    class Fifth final: public jni::JavaClass<Fifth, JVariant_Boolean_DoubleArray_Array_String__Double_String> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__String_Double$Fifth;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__Double_String$Fifth;";
     
-      [[nodiscard]] double getValue() const {
-        static const auto field = javaClassStatic()->getField<double>("value");
+      [[nodiscard]] jni::local_ref<jni::JString> getValue() const {
+        static const auto field = javaClassStatic()->getField<jni::JString>("value");
         return getFieldValue(field);
       }
     };
-  } // namespace JVariant_Boolean_DoubleArray_Array_String__String_Double_impl
+  } // namespace JVariant_Boolean_DoubleArray_Array_String__Double_String_impl
 } // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_WeirdNumbersEnum.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_WeirdNumbersEnum.cpp
deleted file mode 100644
index feaa01bf1a..0000000000
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_WeirdNumbersEnum.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-///
-/// JVariant_Boolean_WeirdNumbersEnum.cpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-#include "JVariant_Boolean_WeirdNumbersEnum.hpp"
-
-namespace margelo::nitro::test {
-  /**
-   * Converts JVariant_Boolean_WeirdNumbersEnum to std::variant<bool, WeirdNumbersEnum>
-   */
-  std::variant<bool, WeirdNumbersEnum> JVariant_Boolean_WeirdNumbersEnum::toCpp() const {
-    if (isInstanceOf(JVariant_Boolean_WeirdNumbersEnum_impl::First::javaClassStatic())) {
-      // It's a `bool`
-      auto jniValue = static_cast<const JVariant_Boolean_WeirdNumbersEnum_impl::First*>(this)->getValue();
-      return static_cast<bool>(jniValue);
-    } else if (isInstanceOf(JVariant_Boolean_WeirdNumbersEnum_impl::Second::javaClassStatic())) {
-      // It's a `WeirdNumbersEnum`
-      auto jniValue = static_cast<const JVariant_Boolean_WeirdNumbersEnum_impl::Second*>(this)->getValue();
-      return jniValue->toCpp();
-    }
-    throw std::invalid_argument("Variant is unknown Kotlin instance!");
-  }
-} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_String_Double.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Double_String.cpp
similarity index 54%
rename from packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_String_Double.cpp
rename to packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Double_String.cpp
index 496245e6f4..6b8449336a 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_String_Double.cpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Double_String.cpp
@@ -1,25 +1,25 @@
 ///
-/// JVariant_String_Double.cpp
+/// JVariant_Double_String.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
-#include "JVariant_String_Double.hpp"
+#include "JVariant_Double_String.hpp"
 
 namespace margelo::nitro::test {
   /**
-   * Converts JVariant_String_Double to std::variant<std::string, double>
+   * Converts JVariant_Double_String to std::variant<double, std::string>
    */
-  std::variant<std::string, double> JVariant_String_Double::toCpp() const {
-    if (isInstanceOf(JVariant_String_Double_impl::First::javaClassStatic())) {
-      // It's a `std::string`
-      auto jniValue = static_cast<const JVariant_String_Double_impl::First*>(this)->getValue();
-      return jniValue->toStdString();
-    } else if (isInstanceOf(JVariant_String_Double_impl::Second::javaClassStatic())) {
+  std::variant<double, std::string> JVariant_Double_String::toCpp() const {
+    if (isInstanceOf(JVariant_Double_String_impl::First::javaClassStatic())) {
       // It's a `double`
-      auto jniValue = static_cast<const JVariant_String_Double_impl::Second*>(this)->getValue();
+      auto jniValue = static_cast<const JVariant_Double_String_impl::First*>(this)->getValue();
       return jniValue;
+    } else if (isInstanceOf(JVariant_Double_String_impl::Second::javaClassStatic())) {
+      // It's a `std::string`
+      auto jniValue = static_cast<const JVariant_Double_String_impl::Second*>(this)->getValue();
+      return jniValue->toStdString();
     }
     throw std::invalid_argument("Variant is unknown Kotlin instance!");
   }
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_String_Double.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Double_String.hpp
similarity index 59%
rename from packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_String_Double.hpp
rename to packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Double_String.hpp
index 47a70c2f7e..fa67a7a668 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_String_Double.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Double_String.hpp
@@ -1,5 +1,5 @@
 ///
-/// JVariant_String_Double.hpp
+/// JVariant_Double_String.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -18,51 +18,51 @@ namespace margelo::nitro::test {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_String_Double".
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_Double_String".
    */
-  class JVariant_String_Double: public jni::JavaClass<JVariant_String_Double> {
+  class JVariant_Double_String: public jni::JavaClass<JVariant_Double_String> {
   public:
-    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_String_Double;";
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Double_String;";
 
-    static jni::local_ref<JVariant_String_Double> create_0(jni::alias_ref<jni::JString> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_String_Double(jni::alias_ref<jni::JString>)>("create");
+    static jni::local_ref<JVariant_Double_String> create_0(double value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Double_String(double)>("create");
       return method(javaClassStatic(), value);
     }
-    static jni::local_ref<JVariant_String_Double> create_1(double value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_String_Double(double)>("create");
+    static jni::local_ref<JVariant_Double_String> create_1(jni::alias_ref<jni::JString> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Double_String(jni::alias_ref<jni::JString>)>("create");
       return method(javaClassStatic(), value);
     }
 
-    static jni::local_ref<JVariant_String_Double> fromCpp(const std::variant<std::string, double>& variant) {
+    static jni::local_ref<JVariant_Double_String> fromCpp(const std::variant<double, std::string>& variant) {
       switch (variant.index()) {
-        case 0: return create_0(jni::make_jstring(std::get<0>(variant)));
-        case 1: return create_1(std::get<1>(variant));
+        case 0: return create_0(std::get<0>(variant));
+        case 1: return create_1(jni::make_jstring(std::get<1>(variant)));
         default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
       }
     }
 
-    [[nodiscard]] std::variant<std::string, double> toCpp() const;
+    [[nodiscard]] std::variant<double, std::string> toCpp() const;
   };
 
-  namespace JVariant_String_Double_impl {
-    class First final: public jni::JavaClass<First, JVariant_String_Double> {
+  namespace JVariant_Double_String_impl {
+    class First final: public jni::JavaClass<First, JVariant_Double_String> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_String_Double$First;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Double_String$First;";
     
-      [[nodiscard]] jni::local_ref<jni::JString> getValue() const {
-        static const auto field = javaClassStatic()->getField<jni::JString>("value");
+      [[nodiscard]] double getValue() const {
+        static const auto field = javaClassStatic()->getField<double>("value");
         return getFieldValue(field);
       }
     };
     
-    class Second final: public jni::JavaClass<Second, JVariant_String_Double> {
+    class Second final: public jni::JavaClass<Second, JVariant_Double_String> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_String_Double$Second;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Double_String$Second;";
     
-      [[nodiscard]] double getValue() const {
-        static const auto field = javaClassStatic()->getField<double>("value");
+      [[nodiscard]] jni::local_ref<jni::JString> getValue() const {
+        static const auto field = javaClassStatic()->getField<jni::JString>("value");
         return getFieldValue(field);
       }
     };
-  } // namespace JVariant_String_Double_impl
+  } // namespace JVariant_Double_String_impl
 } // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_OldEnum.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_OldEnum_Boolean.cpp
similarity index 54%
rename from packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_OldEnum.cpp
rename to packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_OldEnum_Boolean.cpp
index 85b32d9640..40bbcb8247 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_OldEnum.cpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_OldEnum_Boolean.cpp
@@ -1,25 +1,25 @@
 ///
-/// JVariant_Boolean_OldEnum.cpp
+/// JVariant_OldEnum_Boolean.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
-#include "JVariant_Boolean_OldEnum.hpp"
+#include "JVariant_OldEnum_Boolean.hpp"
 
 namespace margelo::nitro::test {
   /**
-   * Converts JVariant_Boolean_OldEnum to std::variant<bool, OldEnum>
+   * Converts JVariant_OldEnum_Boolean to std::variant<OldEnum, bool>
    */
-  std::variant<bool, OldEnum> JVariant_Boolean_OldEnum::toCpp() const {
-    if (isInstanceOf(JVariant_Boolean_OldEnum_impl::First::javaClassStatic())) {
-      // It's a `bool`
-      auto jniValue = static_cast<const JVariant_Boolean_OldEnum_impl::First*>(this)->getValue();
-      return static_cast<bool>(jniValue);
-    } else if (isInstanceOf(JVariant_Boolean_OldEnum_impl::Second::javaClassStatic())) {
+  std::variant<OldEnum, bool> JVariant_OldEnum_Boolean::toCpp() const {
+    if (isInstanceOf(JVariant_OldEnum_Boolean_impl::First::javaClassStatic())) {
       // It's a `OldEnum`
-      auto jniValue = static_cast<const JVariant_Boolean_OldEnum_impl::Second*>(this)->getValue();
+      auto jniValue = static_cast<const JVariant_OldEnum_Boolean_impl::First*>(this)->getValue();
       return jniValue->toCpp();
+    } else if (isInstanceOf(JVariant_OldEnum_Boolean_impl::Second::javaClassStatic())) {
+      // It's a `bool`
+      auto jniValue = static_cast<const JVariant_OldEnum_Boolean_impl::Second*>(this)->getValue();
+      return static_cast<bool>(jniValue);
     }
     throw std::invalid_argument("Variant is unknown Kotlin instance!");
   }
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_OldEnum.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_OldEnum_Boolean.hpp
similarity index 59%
rename from packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_OldEnum.hpp
rename to packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_OldEnum_Boolean.hpp
index 9e33352f2b..abd9c50402 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_OldEnum.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_OldEnum_Boolean.hpp
@@ -1,5 +1,5 @@
 ///
-/// JVariant_Boolean_OldEnum.hpp
+/// JVariant_OldEnum_Boolean.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -19,51 +19,51 @@ namespace margelo::nitro::test {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_Boolean_OldEnum".
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_OldEnum_Boolean".
    */
-  class JVariant_Boolean_OldEnum: public jni::JavaClass<JVariant_Boolean_OldEnum> {
+  class JVariant_OldEnum_Boolean: public jni::JavaClass<JVariant_OldEnum_Boolean> {
   public:
-    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_OldEnum;";
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_OldEnum_Boolean;";
 
-    static jni::local_ref<JVariant_Boolean_OldEnum> create_0(jboolean value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_OldEnum(jboolean)>("create");
+    static jni::local_ref<JVariant_OldEnum_Boolean> create_0(jni::alias_ref<JOldEnum> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_OldEnum_Boolean(jni::alias_ref<JOldEnum>)>("create");
       return method(javaClassStatic(), value);
     }
-    static jni::local_ref<JVariant_Boolean_OldEnum> create_1(jni::alias_ref<JOldEnum> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_OldEnum(jni::alias_ref<JOldEnum>)>("create");
+    static jni::local_ref<JVariant_OldEnum_Boolean> create_1(jboolean value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_OldEnum_Boolean(jboolean)>("create");
       return method(javaClassStatic(), value);
     }
 
-    static jni::local_ref<JVariant_Boolean_OldEnum> fromCpp(const std::variant<bool, OldEnum>& variant) {
+    static jni::local_ref<JVariant_OldEnum_Boolean> fromCpp(const std::variant<OldEnum, bool>& variant) {
       switch (variant.index()) {
-        case 0: return create_0(std::get<0>(variant));
-        case 1: return create_1(JOldEnum::fromCpp(std::get<1>(variant)));
+        case 0: return create_0(JOldEnum::fromCpp(std::get<0>(variant)));
+        case 1: return create_1(std::get<1>(variant));
         default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
       }
     }
 
-    [[nodiscard]] std::variant<bool, OldEnum> toCpp() const;
+    [[nodiscard]] std::variant<OldEnum, bool> toCpp() const;
   };
 
-  namespace JVariant_Boolean_OldEnum_impl {
-    class First final: public jni::JavaClass<First, JVariant_Boolean_OldEnum> {
+  namespace JVariant_OldEnum_Boolean_impl {
+    class First final: public jni::JavaClass<First, JVariant_OldEnum_Boolean> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_OldEnum$First;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_OldEnum_Boolean$First;";
     
-      [[nodiscard]] jboolean getValue() const {
-        static const auto field = javaClassStatic()->getField<jboolean>("value");
+      [[nodiscard]] jni::local_ref<JOldEnum> getValue() const {
+        static const auto field = javaClassStatic()->getField<JOldEnum>("value");
         return getFieldValue(field);
       }
     };
     
-    class Second final: public jni::JavaClass<Second, JVariant_Boolean_OldEnum> {
+    class Second final: public jni::JavaClass<Second, JVariant_OldEnum_Boolean> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_OldEnum$Second;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_OldEnum_Boolean$Second;";
     
-      [[nodiscard]] jni::local_ref<JOldEnum> getValue() const {
-        static const auto field = javaClassStatic()->getField<JOldEnum>("value");
+      [[nodiscard]] jboolean getValue() const {
+        static const auto field = javaClassStatic()->getField<jboolean>("value");
         return getFieldValue(field);
       }
     };
-  } // namespace JVariant_Boolean_OldEnum_impl
+  } // namespace JVariant_OldEnum_Boolean_impl
 } // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Car_Person.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Person_Car.cpp
similarity index 53%
rename from packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Car_Person.cpp
rename to packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Person_Car.cpp
index ca610976c8..fdd747a970 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Car_Person.cpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Person_Car.cpp
@@ -1,24 +1,24 @@
 ///
-/// JVariant_Car_Person.cpp
+/// JVariant_Person_Car.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
-#include "JVariant_Car_Person.hpp"
+#include "JVariant_Person_Car.hpp"
 
 namespace margelo::nitro::test {
   /**
-   * Converts JVariant_Car_Person to std::variant<Car, Person>
+   * Converts JVariant_Person_Car to std::variant<Person, Car>
    */
-  std::variant<Car, Person> JVariant_Car_Person::toCpp() const {
-    if (isInstanceOf(JVariant_Car_Person_impl::First::javaClassStatic())) {
-      // It's a `Car`
-      auto jniValue = static_cast<const JVariant_Car_Person_impl::First*>(this)->getValue();
-      return jniValue->toCpp();
-    } else if (isInstanceOf(JVariant_Car_Person_impl::Second::javaClassStatic())) {
+  std::variant<Person, Car> JVariant_Person_Car::toCpp() const {
+    if (isInstanceOf(JVariant_Person_Car_impl::First::javaClassStatic())) {
       // It's a `Person`
-      auto jniValue = static_cast<const JVariant_Car_Person_impl::Second*>(this)->getValue();
+      auto jniValue = static_cast<const JVariant_Person_Car_impl::First*>(this)->getValue();
+      return jniValue->toCpp();
+    } else if (isInstanceOf(JVariant_Person_Car_impl::Second::javaClassStatic())) {
+      // It's a `Car`
+      auto jniValue = static_cast<const JVariant_Person_Car_impl::Second*>(this)->getValue();
       return jniValue->toCpp();
     }
     throw std::invalid_argument("Variant is unknown Kotlin instance!");
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Car_Person.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Person_Car.hpp
similarity index 62%
rename from packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Car_Person.hpp
rename to packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Person_Car.hpp
index 40c6e67c26..f7797d00d9 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Car_Person.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Person_Car.hpp
@@ -1,5 +1,5 @@
 ///
-/// JVariant_Car_Person.hpp
+/// JVariant_Person_Car.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -10,68 +10,68 @@
 #include <fbjni/fbjni.h>
 #include <variant>
 
-#include "Car.hpp"
 #include "Person.hpp"
+#include "Car.hpp"
 #include <variant>
-#include "JCar.hpp"
+#include "JPerson.hpp"
 #include <string>
+#include "JCar.hpp"
 #include "Powertrain.hpp"
 #include "JPowertrain.hpp"
 #include <optional>
-#include "JPerson.hpp"
 #include <vector>
-#include "JVariant_String_Double.hpp"
+#include "JVariant_Double_String.hpp"
 
 namespace margelo::nitro::test {
 
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_Car_Person".
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_Person_Car".
    */
-  class JVariant_Car_Person: public jni::JavaClass<JVariant_Car_Person> {
+  class JVariant_Person_Car: public jni::JavaClass<JVariant_Person_Car> {
   public:
-    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Car_Person;";
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Person_Car;";
 
-    static jni::local_ref<JVariant_Car_Person> create_0(jni::alias_ref<JCar> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Car_Person(jni::alias_ref<JCar>)>("create");
+    static jni::local_ref<JVariant_Person_Car> create_0(jni::alias_ref<JPerson> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Person_Car(jni::alias_ref<JPerson>)>("create");
       return method(javaClassStatic(), value);
     }
-    static jni::local_ref<JVariant_Car_Person> create_1(jni::alias_ref<JPerson> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Car_Person(jni::alias_ref<JPerson>)>("create");
+    static jni::local_ref<JVariant_Person_Car> create_1(jni::alias_ref<JCar> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Person_Car(jni::alias_ref<JCar>)>("create");
       return method(javaClassStatic(), value);
     }
 
-    static jni::local_ref<JVariant_Car_Person> fromCpp(const std::variant<Car, Person>& variant) {
+    static jni::local_ref<JVariant_Person_Car> fromCpp(const std::variant<Person, Car>& variant) {
       switch (variant.index()) {
-        case 0: return create_0(JCar::fromCpp(std::get<0>(variant)));
-        case 1: return create_1(JPerson::fromCpp(std::get<1>(variant)));
+        case 0: return create_0(JPerson::fromCpp(std::get<0>(variant)));
+        case 1: return create_1(JCar::fromCpp(std::get<1>(variant)));
         default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
       }
     }
 
-    [[nodiscard]] std::variant<Car, Person> toCpp() const;
+    [[nodiscard]] std::variant<Person, Car> toCpp() const;
   };
 
-  namespace JVariant_Car_Person_impl {
-    class First final: public jni::JavaClass<First, JVariant_Car_Person> {
+  namespace JVariant_Person_Car_impl {
+    class First final: public jni::JavaClass<First, JVariant_Person_Car> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Car_Person$First;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Person_Car$First;";
     
-      [[nodiscard]] jni::local_ref<JCar> getValue() const {
-        static const auto field = javaClassStatic()->getField<JCar>("value");
+      [[nodiscard]] jni::local_ref<JPerson> getValue() const {
+        static const auto field = javaClassStatic()->getField<JPerson>("value");
         return getFieldValue(field);
       }
     };
     
-    class Second final: public jni::JavaClass<Second, JVariant_Car_Person> {
+    class Second final: public jni::JavaClass<Second, JVariant_Person_Car> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Car_Person$Second;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Person_Car$Second;";
     
-      [[nodiscard]] jni::local_ref<JPerson> getValue() const {
-        static const auto field = javaClassStatic()->getField<JPerson>("value");
+      [[nodiscard]] jni::local_ref<JCar> getValue() const {
+        static const auto field = javaClassStatic()->getField<JCar>("value");
         return getFieldValue(field);
       }
     };
-  } // namespace JVariant_Car_Person_impl
+  } // namespace JVariant_Person_Car_impl
 } // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Powertrain_Car.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Powertrain_Car.cpp
new file mode 100644
index 0000000000..c6d85bd301
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Powertrain_Car.cpp
@@ -0,0 +1,26 @@
+///
+/// JVariant_Powertrain_Car.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JVariant_Powertrain_Car.hpp"
+
+namespace margelo::nitro::test {
+  /**
+   * Converts JVariant_Powertrain_Car to std::variant<Powertrain, Car>
+   */
+  std::variant<Powertrain, Car> JVariant_Powertrain_Car::toCpp() const {
+    if (isInstanceOf(JVariant_Powertrain_Car_impl::First::javaClassStatic())) {
+      // It's a `Powertrain`
+      auto jniValue = static_cast<const JVariant_Powertrain_Car_impl::First*>(this)->getValue();
+      return jniValue->toCpp();
+    } else if (isInstanceOf(JVariant_Powertrain_Car_impl::Second::javaClassStatic())) {
+      // It's a `Car`
+      auto jniValue = static_cast<const JVariant_Powertrain_Car_impl::Second*>(this)->getValue();
+      return jniValue->toCpp();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Powertrain_Car.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Powertrain_Car.hpp
new file mode 100644
index 0000000000..723ece4c19
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Powertrain_Car.hpp
@@ -0,0 +1,77 @@
+///
+/// JVariant_Powertrain_Car.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 <variant>
+
+#include "Powertrain.hpp"
+#include "Car.hpp"
+#include <variant>
+#include "JPowertrain.hpp"
+#include "JCar.hpp"
+#include <string>
+#include "Person.hpp"
+#include <optional>
+#include "JPerson.hpp"
+#include <vector>
+#include "JVariant_Double_String.hpp"
+
+namespace margelo::nitro::test {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_Powertrain_Car".
+   */
+  class JVariant_Powertrain_Car: public jni::JavaClass<JVariant_Powertrain_Car> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Powertrain_Car;";
+
+    static jni::local_ref<JVariant_Powertrain_Car> create_0(jni::alias_ref<JPowertrain> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Powertrain_Car(jni::alias_ref<JPowertrain>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_Powertrain_Car> create_1(jni::alias_ref<JCar> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Powertrain_Car(jni::alias_ref<JCar>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_Powertrain_Car> fromCpp(const std::variant<Powertrain, Car>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JPowertrain::fromCpp(std::get<0>(variant)));
+        case 1: return create_1(JCar::fromCpp(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<Powertrain, Car> toCpp() const;
+  };
+
+  namespace JVariant_Powertrain_Car_impl {
+    class First final: public jni::JavaClass<First, JVariant_Powertrain_Car> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Powertrain_Car$First;";
+    
+      [[nodiscard]] jni::local_ref<JPowertrain> getValue() const {
+        static const auto field = javaClassStatic()->getField<JPowertrain>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JVariant_Powertrain_Car> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Powertrain_Car$Second;";
+    
+      [[nodiscard]] jni::local_ref<JCar> getValue() const {
+        static const auto field = javaClassStatic()->getField<JCar>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_Powertrain_Car_impl
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_WeirdNumbersEnum_Boolean.cpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_WeirdNumbersEnum_Boolean.cpp
new file mode 100644
index 0000000000..63b7833c1a
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_WeirdNumbersEnum_Boolean.cpp
@@ -0,0 +1,26 @@
+///
+/// JVariant_WeirdNumbersEnum_Boolean.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JVariant_WeirdNumbersEnum_Boolean.hpp"
+
+namespace margelo::nitro::test {
+  /**
+   * Converts JVariant_WeirdNumbersEnum_Boolean to std::variant<WeirdNumbersEnum, bool>
+   */
+  std::variant<WeirdNumbersEnum, bool> JVariant_WeirdNumbersEnum_Boolean::toCpp() const {
+    if (isInstanceOf(JVariant_WeirdNumbersEnum_Boolean_impl::First::javaClassStatic())) {
+      // It's a `WeirdNumbersEnum`
+      auto jniValue = static_cast<const JVariant_WeirdNumbersEnum_Boolean_impl::First*>(this)->getValue();
+      return jniValue->toCpp();
+    } else if (isInstanceOf(JVariant_WeirdNumbersEnum_Boolean_impl::Second::javaClassStatic())) {
+      // It's a `bool`
+      auto jniValue = static_cast<const JVariant_WeirdNumbersEnum_Boolean_impl::Second*>(this)->getValue();
+      return static_cast<bool>(jniValue);
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_WeirdNumbersEnum.hpp b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_WeirdNumbersEnum_Boolean.hpp
similarity index 54%
rename from packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_WeirdNumbersEnum.hpp
rename to packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_WeirdNumbersEnum_Boolean.hpp
index eca8f9e972..07f72a82da 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_Boolean_WeirdNumbersEnum.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/c++/JVariant_WeirdNumbersEnum_Boolean.hpp
@@ -1,5 +1,5 @@
 ///
-/// JVariant_Boolean_WeirdNumbersEnum.hpp
+/// JVariant_WeirdNumbersEnum_Boolean.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -19,51 +19,51 @@ namespace margelo::nitro::test {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_Boolean_WeirdNumbersEnum".
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_WeirdNumbersEnum_Boolean".
    */
-  class JVariant_Boolean_WeirdNumbersEnum: public jni::JavaClass<JVariant_Boolean_WeirdNumbersEnum> {
+  class JVariant_WeirdNumbersEnum_Boolean: public jni::JavaClass<JVariant_WeirdNumbersEnum_Boolean> {
   public:
-    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_WeirdNumbersEnum;";
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_WeirdNumbersEnum_Boolean;";
 
-    static jni::local_ref<JVariant_Boolean_WeirdNumbersEnum> create_0(jboolean value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_WeirdNumbersEnum(jboolean)>("create");
+    static jni::local_ref<JVariant_WeirdNumbersEnum_Boolean> create_0(jni::alias_ref<JWeirdNumbersEnum> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_WeirdNumbersEnum_Boolean(jni::alias_ref<JWeirdNumbersEnum>)>("create");
       return method(javaClassStatic(), value);
     }
-    static jni::local_ref<JVariant_Boolean_WeirdNumbersEnum> create_1(jni::alias_ref<JWeirdNumbersEnum> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_Boolean_WeirdNumbersEnum(jni::alias_ref<JWeirdNumbersEnum>)>("create");
+    static jni::local_ref<JVariant_WeirdNumbersEnum_Boolean> create_1(jboolean value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_WeirdNumbersEnum_Boolean(jboolean)>("create");
       return method(javaClassStatic(), value);
     }
 
-    static jni::local_ref<JVariant_Boolean_WeirdNumbersEnum> fromCpp(const std::variant<bool, WeirdNumbersEnum>& variant) {
+    static jni::local_ref<JVariant_WeirdNumbersEnum_Boolean> fromCpp(const std::variant<WeirdNumbersEnum, bool>& variant) {
       switch (variant.index()) {
-        case 0: return create_0(std::get<0>(variant));
-        case 1: return create_1(JWeirdNumbersEnum::fromCpp(std::get<1>(variant)));
+        case 0: return create_0(JWeirdNumbersEnum::fromCpp(std::get<0>(variant)));
+        case 1: return create_1(std::get<1>(variant));
         default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
       }
     }
 
-    [[nodiscard]] std::variant<bool, WeirdNumbersEnum> toCpp() const;
+    [[nodiscard]] std::variant<WeirdNumbersEnum, bool> toCpp() const;
   };
 
-  namespace JVariant_Boolean_WeirdNumbersEnum_impl {
-    class First final: public jni::JavaClass<First, JVariant_Boolean_WeirdNumbersEnum> {
+  namespace JVariant_WeirdNumbersEnum_Boolean_impl {
+    class First final: public jni::JavaClass<First, JVariant_WeirdNumbersEnum_Boolean> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_WeirdNumbersEnum$First;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_WeirdNumbersEnum_Boolean$First;";
     
-      [[nodiscard]] jboolean getValue() const {
-        static const auto field = javaClassStatic()->getField<jboolean>("value");
+      [[nodiscard]] jni::local_ref<JWeirdNumbersEnum> getValue() const {
+        static const auto field = javaClassStatic()->getField<JWeirdNumbersEnum>("value");
         return getFieldValue(field);
       }
     };
     
-    class Second final: public jni::JavaClass<Second, JVariant_Boolean_WeirdNumbersEnum> {
+    class Second final: public jni::JavaClass<Second, JVariant_WeirdNumbersEnum_Boolean> {
     public:
-      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_Boolean_WeirdNumbersEnum$Second;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/test/Variant_WeirdNumbersEnum_Boolean$Second;";
     
-      [[nodiscard]] jni::local_ref<JWeirdNumbersEnum> getValue() const {
-        static const auto field = javaClassStatic()->getField<JWeirdNumbersEnum>("value");
+      [[nodiscard]] jboolean getValue() const {
+        static const auto field = javaClassStatic()->getField<jboolean>("value");
         return getFieldValue(field);
       }
     };
-  } // namespace JVariant_Boolean_WeirdNumbersEnum_impl
+  } // namespace JVariant_WeirdNumbersEnum_Boolean_impl
 } // namespace margelo::nitro::test
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Car.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Car.kt
index f786227320..384352d325 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Car.kt
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Car.kt
@@ -50,7 +50,7 @@ data class Car(
   val performanceScores: DoubleArray,
   @DoNotStrip
   @Keep
-  val someVariant: Variant_String_Double?
+  val someVariant: Variant_Double_String?
 ) {
   /* primary constructor */
 
@@ -94,7 +94,7 @@ data class Car(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(year: Double, make: String, model: String, power: Double, powertrain: Powertrain, driver: Person?, passengers: Array<Person>, isFast: Boolean?, favouriteTrack: String?, performanceScores: DoubleArray, someVariant: Variant_String_Double?): Car {
+    private fun fromCpp(year: Double, make: String, model: String, power: Double, powertrain: Powertrain, driver: Person?, passengers: Array<Person>, isFast: Boolean?, favouriteTrack: String?, performanceScores: DoubleArray, someVariant: Variant_Double_String?): Car {
       return Car(year, make, model, power, powertrain, driver, passengers, isFast, favouriteTrack, performanceScores, someVariant)
     }
   }
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 a343c76528..9e6d0609f1 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
@@ -158,7 +158,7 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
   @get:Keep
   @set:DoNotStrip
   @set:Keep
-  abstract var someVariant: Variant_String_Double
+  abstract var someVariant: Variant_Double_String
 
   // Methods
   @DoNotStrip
@@ -554,19 +554,23 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun passVariant(either: Variant_Boolean_DoubleArray_Array_String__String_Double): Variant_String_Double
+  abstract fun passVariant(either: Variant_Boolean_DoubleArray_Array_String__Double_String): Variant_Double_String
   
   @DoNotStrip
   @Keep
-  abstract fun getVariantEnum(variant: Variant_Boolean_OldEnum): Variant_Boolean_OldEnum
+  abstract fun getVariantEnum(variant: Variant_OldEnum_Boolean): Variant_OldEnum_Boolean
   
   @DoNotStrip
   @Keep
-  abstract fun getVariantWeirdNumbersEnum(variant: Variant_Boolean_WeirdNumbersEnum): Variant_Boolean_WeirdNumbersEnum
+  abstract fun bounceVariantUnionEnum(variant: Variant_Powertrain_Car): Variant_Powertrain_Car
   
   @DoNotStrip
   @Keep
-  abstract fun getVariantObjects(variant: Variant_Car_Person): Variant_Car_Person
+  abstract fun getVariantWeirdNumbersEnum(variant: Variant_WeirdNumbersEnum_Boolean): Variant_WeirdNumbersEnum_Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getVariantObjects(variant: Variant_Person_Car): Variant_Person_Car
   
   @DoNotStrip
   @Keep
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__String_Double.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__Double_String.kt
similarity index 73%
rename from packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__String_Double.kt
rename to packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__Double_String.kt
index e4ba8a9f28..c94a251c8d 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__String_Double.kt
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_DoubleArray_Array_String__Double_String.kt
@@ -1,5 +1,5 @@
 ///
-/// Variant_Boolean_DoubleArray_Array_String__String_Double.kt
+/// Variant_Boolean_DoubleArray_Array_String__Double_String.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -11,21 +11,21 @@ import com.facebook.proguard.annotations.DoNotStrip
 
 
 /**
- * Represents the TypeScript variant "Boolean | DoubleArray | Array<String> | String | Double".
+ * Represents the TypeScript variant "Boolean | DoubleArray | Array<String> | Double | String".
  */
 @Suppress("ClassName")
 @DoNotStrip
-sealed class Variant_Boolean_DoubleArray_Array_String__String_Double {
+sealed class Variant_Boolean_DoubleArray_Array_String__Double_String {
   @DoNotStrip
-  data class First(@DoNotStrip val value: Boolean): Variant_Boolean_DoubleArray_Array_String__String_Double()
+  data class First(@DoNotStrip val value: Boolean): Variant_Boolean_DoubleArray_Array_String__Double_String()
   @DoNotStrip
-  data class Second(@DoNotStrip val value: DoubleArray): Variant_Boolean_DoubleArray_Array_String__String_Double()
+  data class Second(@DoNotStrip val value: DoubleArray): Variant_Boolean_DoubleArray_Array_String__Double_String()
   @DoNotStrip
-  data class Third(@DoNotStrip val value: Array<String>): Variant_Boolean_DoubleArray_Array_String__String_Double()
+  data class Third(@DoNotStrip val value: Array<String>): Variant_Boolean_DoubleArray_Array_String__Double_String()
   @DoNotStrip
-  data class Fourth(@DoNotStrip val value: String): Variant_Boolean_DoubleArray_Array_String__String_Double()
+  data class Fourth(@DoNotStrip val value: Double): Variant_Boolean_DoubleArray_Array_String__Double_String()
   @DoNotStrip
-  data class Fifth(@DoNotStrip val value: Double): Variant_Boolean_DoubleArray_Array_String__String_Double()
+  data class Fifth(@DoNotStrip val value: String): Variant_Boolean_DoubleArray_Array_String__Double_String()
 
   inline fun <reified T> asType(): T? {
     return when (this) {
@@ -39,7 +39,7 @@ sealed class Variant_Boolean_DoubleArray_Array_String__String_Double {
   inline fun <reified T> isType(): Boolean {
     return asType<T>() != null
   }
-  inline fun <R> match(first: (Boolean) -> R, second: (DoubleArray) -> R, third: (Array<String>) -> R, fourth: (String) -> R, fifth: (Double) -> R): R {
+  inline fun <R> match(first: (Boolean) -> R, second: (DoubleArray) -> R, third: (Array<String>) -> R, fourth: (Double) -> R, fifth: (String) -> R): R {
     return when (this) {
       is First -> first(value)
       is Second -> second(value)
@@ -72,11 +72,11 @@ sealed class Variant_Boolean_DoubleArray_Array_String__String_Double {
     val value = (this as? Third)?.value ?: return null
     return value
   }
-  fun asFourthOrNull(): String? {
+  fun asFourthOrNull(): Double? {
     val value = (this as? Fourth)?.value ?: return null
     return value
   }
-  fun asFifthOrNull(): Double? {
+  fun asFifthOrNull(): String? {
     val value = (this as? Fifth)?.value ?: return null
     return value
   }
@@ -84,18 +84,18 @@ sealed class Variant_Boolean_DoubleArray_Array_String__String_Double {
   companion object {
     @JvmStatic
     @DoNotStrip
-    fun create(value: Boolean): Variant_Boolean_DoubleArray_Array_String__String_Double = First(value)
+    fun create(value: Boolean): Variant_Boolean_DoubleArray_Array_String__Double_String = First(value)
     @JvmStatic
     @DoNotStrip
-    fun create(value: DoubleArray): Variant_Boolean_DoubleArray_Array_String__String_Double = Second(value)
+    fun create(value: DoubleArray): Variant_Boolean_DoubleArray_Array_String__Double_String = Second(value)
     @JvmStatic
     @DoNotStrip
-    fun create(value: Array<String>): Variant_Boolean_DoubleArray_Array_String__String_Double = Third(value)
+    fun create(value: Array<String>): Variant_Boolean_DoubleArray_Array_String__Double_String = Third(value)
     @JvmStatic
     @DoNotStrip
-    fun create(value: String): Variant_Boolean_DoubleArray_Array_String__String_Double = Fourth(value)
+    fun create(value: Double): Variant_Boolean_DoubleArray_Array_String__Double_String = Fourth(value)
     @JvmStatic
     @DoNotStrip
-    fun create(value: Double): Variant_Boolean_DoubleArray_Array_String__String_Double = Fifth(value)
+    fun create(value: String): Variant_Boolean_DoubleArray_Array_String__Double_String = Fifth(value)
   }
 }
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_String_Double.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Double_String.kt
similarity index 65%
rename from packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_String_Double.kt
rename to packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Double_String.kt
index 80527fa2c1..eb0d6ba168 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_String_Double.kt
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Double_String.kt
@@ -1,5 +1,5 @@
 ///
-/// Variant_String_Double.kt
+/// Variant_Double_String.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -11,15 +11,15 @@ import com.facebook.proguard.annotations.DoNotStrip
 
 
 /**
- * Represents the TypeScript variant "String | Double".
+ * Represents the TypeScript variant "Double | String".
  */
 @Suppress("ClassName")
 @DoNotStrip
-sealed class Variant_String_Double {
+sealed class Variant_Double_String {
   @DoNotStrip
-  data class First(@DoNotStrip val value: String): Variant_String_Double()
+  data class First(@DoNotStrip val value: Double): Variant_Double_String()
   @DoNotStrip
-  data class Second(@DoNotStrip val value: Double): Variant_String_Double()
+  data class Second(@DoNotStrip val value: String): Variant_Double_String()
 
   inline fun <reified T> asType(): T? {
     return when (this) {
@@ -30,7 +30,7 @@ sealed class Variant_String_Double {
   inline fun <reified T> isType(): Boolean {
     return asType<T>() != null
   }
-  inline fun <R> match(first: (String) -> R, second: (Double) -> R): R {
+  inline fun <R> match(first: (Double) -> R, second: (String) -> R): R {
     return when (this) {
       is First -> first(value)
       is Second -> second(value)
@@ -42,11 +42,11 @@ sealed class Variant_String_Double {
   val isSecond: Boolean
     get() = this is Second
 
-  fun asFirstOrNull(): String? {
+  fun asFirstOrNull(): Double? {
     val value = (this as? First)?.value ?: return null
     return value
   }
-  fun asSecondOrNull(): Double? {
+  fun asSecondOrNull(): String? {
     val value = (this as? Second)?.value ?: return null
     return value
   }
@@ -54,9 +54,9 @@ sealed class Variant_String_Double {
   companion object {
     @JvmStatic
     @DoNotStrip
-    fun create(value: String): Variant_String_Double = First(value)
+    fun create(value: Double): Variant_Double_String = First(value)
     @JvmStatic
     @DoNotStrip
-    fun create(value: Double): Variant_String_Double = Second(value)
+    fun create(value: String): Variant_Double_String = Second(value)
   }
 }
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_OldEnum.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_OldEnum_Boolean.kt
similarity index 64%
rename from packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_OldEnum.kt
rename to packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_OldEnum_Boolean.kt
index 7d08cb03f3..299e286091 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_OldEnum.kt
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_OldEnum_Boolean.kt
@@ -1,5 +1,5 @@
 ///
-/// Variant_Boolean_OldEnum.kt
+/// Variant_OldEnum_Boolean.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -11,15 +11,15 @@ import com.facebook.proguard.annotations.DoNotStrip
 
 
 /**
- * Represents the TypeScript variant "Boolean | OldEnum".
+ * Represents the TypeScript variant "OldEnum | Boolean".
  */
 @Suppress("ClassName")
 @DoNotStrip
-sealed class Variant_Boolean_OldEnum {
+sealed class Variant_OldEnum_Boolean {
   @DoNotStrip
-  data class First(@DoNotStrip val value: Boolean): Variant_Boolean_OldEnum()
+  data class First(@DoNotStrip val value: OldEnum): Variant_OldEnum_Boolean()
   @DoNotStrip
-  data class Second(@DoNotStrip val value: OldEnum): Variant_Boolean_OldEnum()
+  data class Second(@DoNotStrip val value: Boolean): Variant_OldEnum_Boolean()
 
   inline fun <reified T> asType(): T? {
     return when (this) {
@@ -30,7 +30,7 @@ sealed class Variant_Boolean_OldEnum {
   inline fun <reified T> isType(): Boolean {
     return asType<T>() != null
   }
-  inline fun <R> match(first: (Boolean) -> R, second: (OldEnum) -> R): R {
+  inline fun <R> match(first: (OldEnum) -> R, second: (Boolean) -> R): R {
     return when (this) {
       is First -> first(value)
       is Second -> second(value)
@@ -42,11 +42,11 @@ sealed class Variant_Boolean_OldEnum {
   val isSecond: Boolean
     get() = this is Second
 
-  fun asFirstOrNull(): Boolean? {
+  fun asFirstOrNull(): OldEnum? {
     val value = (this as? First)?.value ?: return null
     return value
   }
-  fun asSecondOrNull(): OldEnum? {
+  fun asSecondOrNull(): Boolean? {
     val value = (this as? Second)?.value ?: return null
     return value
   }
@@ -54,9 +54,9 @@ sealed class Variant_Boolean_OldEnum {
   companion object {
     @JvmStatic
     @DoNotStrip
-    fun create(value: Boolean): Variant_Boolean_OldEnum = First(value)
+    fun create(value: OldEnum): Variant_OldEnum_Boolean = First(value)
     @JvmStatic
     @DoNotStrip
-    fun create(value: OldEnum): Variant_Boolean_OldEnum = Second(value)
+    fun create(value: Boolean): Variant_OldEnum_Boolean = Second(value)
   }
 }
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Car_Person.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Person_Car.kt
similarity index 65%
rename from packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Car_Person.kt
rename to packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Person_Car.kt
index 4614cc0078..2823b42b3a 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Car_Person.kt
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Person_Car.kt
@@ -1,5 +1,5 @@
 ///
-/// Variant_Car_Person.kt
+/// Variant_Person_Car.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -11,15 +11,15 @@ import com.facebook.proguard.annotations.DoNotStrip
 
 
 /**
- * Represents the TypeScript variant "Car | Person".
+ * Represents the TypeScript variant "Person | Car".
  */
 @Suppress("ClassName")
 @DoNotStrip
-sealed class Variant_Car_Person {
+sealed class Variant_Person_Car {
   @DoNotStrip
-  data class First(@DoNotStrip val value: Car): Variant_Car_Person()
+  data class First(@DoNotStrip val value: Person): Variant_Person_Car()
   @DoNotStrip
-  data class Second(@DoNotStrip val value: Person): Variant_Car_Person()
+  data class Second(@DoNotStrip val value: Car): Variant_Person_Car()
 
   inline fun <reified T> asType(): T? {
     return when (this) {
@@ -30,7 +30,7 @@ sealed class Variant_Car_Person {
   inline fun <reified T> isType(): Boolean {
     return asType<T>() != null
   }
-  inline fun <R> match(first: (Car) -> R, second: (Person) -> R): R {
+  inline fun <R> match(first: (Person) -> R, second: (Car) -> R): R {
     return when (this) {
       is First -> first(value)
       is Second -> second(value)
@@ -42,11 +42,11 @@ sealed class Variant_Car_Person {
   val isSecond: Boolean
     get() = this is Second
 
-  fun asFirstOrNull(): Car? {
+  fun asFirstOrNull(): Person? {
     val value = (this as? First)?.value ?: return null
     return value
   }
-  fun asSecondOrNull(): Person? {
+  fun asSecondOrNull(): Car? {
     val value = (this as? Second)?.value ?: return null
     return value
   }
@@ -54,9 +54,9 @@ sealed class Variant_Car_Person {
   companion object {
     @JvmStatic
     @DoNotStrip
-    fun create(value: Car): Variant_Car_Person = First(value)
+    fun create(value: Person): Variant_Person_Car = First(value)
     @JvmStatic
     @DoNotStrip
-    fun create(value: Person): Variant_Car_Person = Second(value)
+    fun create(value: Car): Variant_Person_Car = Second(value)
   }
 }
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Powertrain_Car.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Powertrain_Car.kt
new file mode 100644
index 0000000000..722d3a68d0
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Powertrain_Car.kt
@@ -0,0 +1,62 @@
+///
+/// Variant_Powertrain_Car.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 com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the TypeScript variant "Powertrain | Car".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class Variant_Powertrain_Car {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: Powertrain): Variant_Powertrain_Car()
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: Car): Variant_Powertrain_Car()
+
+  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: (Powertrain) -> R, second: (Car) -> 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(): Powertrain? {
+    val value = (this as? First)?.value ?: return null
+    return value
+  }
+  fun asSecondOrNull(): Car? {
+    val value = (this as? Second)?.value ?: return null
+    return value
+  }
+
+  companion object {
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: Powertrain): Variant_Powertrain_Car = First(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: Car): Variant_Powertrain_Car = Second(value)
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_WeirdNumbersEnum.kt b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_WeirdNumbersEnum_Boolean.kt
similarity index 59%
rename from packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_WeirdNumbersEnum.kt
rename to packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_WeirdNumbersEnum_Boolean.kt
index d5b7b59249..406529bdc8 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_Boolean_WeirdNumbersEnum.kt
+++ b/packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/Variant_WeirdNumbersEnum_Boolean.kt
@@ -1,5 +1,5 @@
 ///
-/// Variant_Boolean_WeirdNumbersEnum.kt
+/// Variant_WeirdNumbersEnum_Boolean.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -11,15 +11,15 @@ import com.facebook.proguard.annotations.DoNotStrip
 
 
 /**
- * Represents the TypeScript variant "Boolean | WeirdNumbersEnum".
+ * Represents the TypeScript variant "WeirdNumbersEnum | Boolean".
  */
 @Suppress("ClassName")
 @DoNotStrip
-sealed class Variant_Boolean_WeirdNumbersEnum {
+sealed class Variant_WeirdNumbersEnum_Boolean {
   @DoNotStrip
-  data class First(@DoNotStrip val value: Boolean): Variant_Boolean_WeirdNumbersEnum()
+  data class First(@DoNotStrip val value: WeirdNumbersEnum): Variant_WeirdNumbersEnum_Boolean()
   @DoNotStrip
-  data class Second(@DoNotStrip val value: WeirdNumbersEnum): Variant_Boolean_WeirdNumbersEnum()
+  data class Second(@DoNotStrip val value: Boolean): Variant_WeirdNumbersEnum_Boolean()
 
   inline fun <reified T> asType(): T? {
     return when (this) {
@@ -30,7 +30,7 @@ sealed class Variant_Boolean_WeirdNumbersEnum {
   inline fun <reified T> isType(): Boolean {
     return asType<T>() != null
   }
-  inline fun <R> match(first: (Boolean) -> R, second: (WeirdNumbersEnum) -> R): R {
+  inline fun <R> match(first: (WeirdNumbersEnum) -> R, second: (Boolean) -> R): R {
     return when (this) {
       is First -> first(value)
       is Second -> second(value)
@@ -42,11 +42,11 @@ sealed class Variant_Boolean_WeirdNumbersEnum {
   val isSecond: Boolean
     get() = this is Second
 
-  fun asFirstOrNull(): Boolean? {
+  fun asFirstOrNull(): WeirdNumbersEnum? {
     val value = (this as? First)?.value ?: return null
     return value
   }
-  fun asSecondOrNull(): WeirdNumbersEnum? {
+  fun asSecondOrNull(): Boolean? {
     val value = (this as? Second)?.value ?: return null
     return value
   }
@@ -54,9 +54,9 @@ sealed class Variant_Boolean_WeirdNumbersEnum {
   companion object {
     @JvmStatic
     @DoNotStrip
-    fun create(value: Boolean): Variant_Boolean_WeirdNumbersEnum = First(value)
+    fun create(value: WeirdNumbersEnum): Variant_WeirdNumbersEnum_Boolean = First(value)
     @JvmStatic
     @DoNotStrip
-    fun create(value: WeirdNumbersEnum): Variant_Boolean_WeirdNumbersEnum = Second(value)
+    fun create(value: Boolean): Variant_WeirdNumbersEnum_Boolean = Second(value)
   }
 }
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp
index c855fea8fb..e8e455998f 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/NitroTest-Swift-Cxx-Bridge.hpp
@@ -187,47 +187,47 @@ namespace margelo::nitro::test::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::variant<std::string, double>
+  // pragma MARK: std::variant<double, std::string>
   /**
-   * Wrapper struct for `std::variant<std::string, double>`.
+   * Wrapper struct for `std::variant<double, std::string>`.
    * std::variant cannot be used in Swift because of a Swift bug.
    * Not even specializing it works. So we create a wrapper struct.
    */
-  struct std__variant_std__string__double_ final {
-    std::variant<std::string, double> variant;
-    std__variant_std__string__double_(std::variant<std::string, double> variant): variant(variant) { }
-    operator std::variant<std::string, double>() const noexcept {
+  struct std__variant_double__std__string_ final {
+    std::variant<double, std::string> variant;
+    std__variant_double__std__string_(std::variant<double, std::string> variant): variant(variant) { }
+    operator std::variant<double, std::string>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
       return variant.index();
     }
-    inline std::string get_0() const noexcept {
+    inline double get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline double get_1() const noexcept {
+    inline std::string get_1() const noexcept {
       return std::get<1>(variant);
     }
   };
-  inline std__variant_std__string__double_ create_std__variant_std__string__double_(const std::string& value) noexcept {
-    return std__variant_std__string__double_(value);
+  inline std__variant_double__std__string_ create_std__variant_double__std__string_(double value) noexcept {
+    return std__variant_double__std__string_(value);
   }
-  inline std__variant_std__string__double_ create_std__variant_std__string__double_(double value) noexcept {
-    return std__variant_std__string__double_(value);
+  inline std__variant_double__std__string_ create_std__variant_double__std__string_(const std::string& value) noexcept {
+    return std__variant_double__std__string_(value);
   }
   
-  // pragma MARK: std::optional<std::variant<std::string, double>>
+  // pragma MARK: std::optional<std::variant<double, std::string>>
   /**
-   * Specialized version of `std::optional<std::variant<std::string, double>>`.
+   * Specialized version of `std::optional<std::variant<double, std::string>>`.
    */
-  using std__optional_std__variant_std__string__double__ = std::optional<std::variant<std::string, double>>;
-  inline std::optional<std::variant<std::string, double>> create_std__optional_std__variant_std__string__double__(const std::variant<std::string, double>& value) noexcept {
-    return std::optional<std::variant<std::string, double>>(value);
+  using std__optional_std__variant_double__std__string__ = std::optional<std::variant<double, std::string>>;
+  inline std::optional<std::variant<double, std::string>> create_std__optional_std__variant_double__std__string__(const std::variant<double, std::string>& value) noexcept {
+    return std::optional<std::variant<double, std::string>>(value);
   }
-  inline bool has_value_std__optional_std__variant_std__string__double__(const std::optional<std::variant<std::string, double>>& optional) noexcept {
+  inline bool has_value_std__optional_std__variant_double__std__string__(const std::optional<std::variant<double, std::string>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::variant<std::string, double> get_std__optional_std__variant_std__string__double__(const std::optional<std::variant<std::string, double>>& optional) noexcept {
+  inline std::variant<double, std::string> get_std__optional_std__variant_double__std__string__(const std::optional<std::variant<double, std::string>>& optional) noexcept {
     return optional.value();
   }
   
@@ -1313,16 +1313,16 @@ namespace margelo::nitro::test::bridge::swift {
     return optional.value();
   }
   
-  // pragma MARK: std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>
+  // pragma MARK: std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>
   /**
-   * Wrapper struct for `std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>`.
+   * Wrapper struct for `std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>`.
    * std::variant cannot be used in Swift because of a Swift bug.
    * Not even specializing it works. So we create a wrapper struct.
    */
-  struct std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_ final {
-    std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double> variant;
-    std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double> variant): variant(variant) { }
-    operator std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>() const noexcept {
+  struct std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_ final {
+    std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string> variant;
+    std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string> variant): variant(variant) { }
+    operator std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
@@ -1337,114 +1337,143 @@ namespace margelo::nitro::test::bridge::swift {
     inline std::vector<std::string> get_2() const noexcept {
       return std::get<2>(variant);
     }
-    inline std::string get_3() const noexcept {
+    inline double get_3() const noexcept {
       return std::get<3>(variant);
     }
-    inline double get_4() const noexcept {
+    inline std::string get_4() const noexcept {
       return std::get<4>(variant);
     }
   };
-  inline std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_ create_std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(bool value) noexcept {
-    return std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(value);
+  inline std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_ create_std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(bool value) noexcept {
+    return std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(value);
   }
-  inline std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_ create_std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(const std::vector<double>& value) noexcept {
-    return std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(value);
+  inline std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_ create_std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(const std::vector<double>& value) noexcept {
+    return std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(value);
   }
-  inline std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_ create_std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(const std::vector<std::string>& value) noexcept {
-    return std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(value);
+  inline std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_ create_std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(const std::vector<std::string>& value) noexcept {
+    return std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(value);
   }
-  inline std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_ create_std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(const std::string& value) noexcept {
-    return std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(value);
+  inline std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_ create_std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(double value) noexcept {
+    return std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(value);
   }
-  inline std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_ create_std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(double value) noexcept {
-    return std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_(value);
+  inline std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_ create_std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(const std::string& value) noexcept {
+    return std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_(value);
   }
   
-  // pragma MARK: std::variant<bool, OldEnum>
+  // pragma MARK: std::variant<OldEnum, bool>
   /**
-   * Wrapper struct for `std::variant<bool, OldEnum>`.
+   * Wrapper struct for `std::variant<OldEnum, bool>`.
    * std::variant cannot be used in Swift because of a Swift bug.
    * Not even specializing it works. So we create a wrapper struct.
    */
-  struct std__variant_bool__OldEnum_ final {
-    std::variant<bool, OldEnum> variant;
-    std__variant_bool__OldEnum_(std::variant<bool, OldEnum> variant): variant(variant) { }
-    operator std::variant<bool, OldEnum>() const noexcept {
+  struct std__variant_OldEnum__bool_ final {
+    std::variant<OldEnum, bool> variant;
+    std__variant_OldEnum__bool_(std::variant<OldEnum, bool> variant): variant(variant) { }
+    operator std::variant<OldEnum, bool>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
       return variant.index();
     }
-    inline bool get_0() const noexcept {
+    inline OldEnum get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline OldEnum get_1() const noexcept {
+    inline bool get_1() const noexcept {
       return std::get<1>(variant);
     }
   };
-  inline std__variant_bool__OldEnum_ create_std__variant_bool__OldEnum_(bool value) noexcept {
-    return std__variant_bool__OldEnum_(value);
+  inline std__variant_OldEnum__bool_ create_std__variant_OldEnum__bool_(OldEnum value) noexcept {
+    return std__variant_OldEnum__bool_(value);
   }
-  inline std__variant_bool__OldEnum_ create_std__variant_bool__OldEnum_(OldEnum value) noexcept {
-    return std__variant_bool__OldEnum_(value);
+  inline std__variant_OldEnum__bool_ create_std__variant_OldEnum__bool_(bool value) noexcept {
+    return std__variant_OldEnum__bool_(value);
   }
   
-  // pragma MARK: std::variant<bool, WeirdNumbersEnum>
+  // pragma MARK: std::variant<Powertrain, Car>
   /**
-   * Wrapper struct for `std::variant<bool, WeirdNumbersEnum>`.
+   * Wrapper struct for `std::variant<Powertrain, Car>`.
    * std::variant cannot be used in Swift because of a Swift bug.
    * Not even specializing it works. So we create a wrapper struct.
    */
-  struct std__variant_bool__WeirdNumbersEnum_ final {
-    std::variant<bool, WeirdNumbersEnum> variant;
-    std__variant_bool__WeirdNumbersEnum_(std::variant<bool, WeirdNumbersEnum> variant): variant(variant) { }
-    operator std::variant<bool, WeirdNumbersEnum>() const noexcept {
+  struct std__variant_Powertrain__Car_ final {
+    std::variant<Powertrain, Car> variant;
+    std__variant_Powertrain__Car_(std::variant<Powertrain, Car> variant): variant(variant) { }
+    operator std::variant<Powertrain, Car>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
       return variant.index();
     }
-    inline bool get_0() const noexcept {
+    inline Powertrain get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline WeirdNumbersEnum get_1() const noexcept {
+    inline Car get_1() const noexcept {
       return std::get<1>(variant);
     }
   };
-  inline std__variant_bool__WeirdNumbersEnum_ create_std__variant_bool__WeirdNumbersEnum_(bool value) noexcept {
-    return std__variant_bool__WeirdNumbersEnum_(value);
+  inline std__variant_Powertrain__Car_ create_std__variant_Powertrain__Car_(Powertrain value) noexcept {
+    return std__variant_Powertrain__Car_(value);
   }
-  inline std__variant_bool__WeirdNumbersEnum_ create_std__variant_bool__WeirdNumbersEnum_(WeirdNumbersEnum value) noexcept {
-    return std__variant_bool__WeirdNumbersEnum_(value);
+  inline std__variant_Powertrain__Car_ create_std__variant_Powertrain__Car_(const Car& value) noexcept {
+    return std__variant_Powertrain__Car_(value);
   }
   
-  // pragma MARK: std::variant<Car, Person>
+  // pragma MARK: std::variant<WeirdNumbersEnum, bool>
   /**
-   * Wrapper struct for `std::variant<Car, Person>`.
+   * Wrapper struct for `std::variant<WeirdNumbersEnum, bool>`.
    * std::variant cannot be used in Swift because of a Swift bug.
    * Not even specializing it works. So we create a wrapper struct.
    */
-  struct std__variant_Car__Person_ final {
-    std::variant<Car, Person> variant;
-    std__variant_Car__Person_(std::variant<Car, Person> variant): variant(variant) { }
-    operator std::variant<Car, Person>() const noexcept {
+  struct std__variant_WeirdNumbersEnum__bool_ final {
+    std::variant<WeirdNumbersEnum, bool> variant;
+    std__variant_WeirdNumbersEnum__bool_(std::variant<WeirdNumbersEnum, bool> variant): variant(variant) { }
+    operator std::variant<WeirdNumbersEnum, bool>() const noexcept {
       return variant;
     }
     inline size_t index() const noexcept {
       return variant.index();
     }
-    inline Car get_0() const noexcept {
+    inline WeirdNumbersEnum get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline Person get_1() const noexcept {
+    inline bool get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_WeirdNumbersEnum__bool_ create_std__variant_WeirdNumbersEnum__bool_(WeirdNumbersEnum value) noexcept {
+    return std__variant_WeirdNumbersEnum__bool_(value);
+  }
+  inline std__variant_WeirdNumbersEnum__bool_ create_std__variant_WeirdNumbersEnum__bool_(bool value) noexcept {
+    return std__variant_WeirdNumbersEnum__bool_(value);
+  }
+  
+  // pragma MARK: std::variant<Person, Car>
+  /**
+   * Wrapper struct for `std::variant<Person, Car>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_Person__Car_ final {
+    std::variant<Person, Car> variant;
+    std__variant_Person__Car_(std::variant<Person, Car> variant): variant(variant) { }
+    operator std::variant<Person, Car>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline Person get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline Car get_1() const noexcept {
       return std::get<1>(variant);
     }
   };
-  inline std__variant_Car__Person_ create_std__variant_Car__Person_(const Car& value) noexcept {
-    return std__variant_Car__Person_(value);
+  inline std__variant_Person__Car_ create_std__variant_Person__Car_(const Person& value) noexcept {
+    return std__variant_Person__Car_(value);
   }
-  inline std__variant_Car__Person_ create_std__variant_Car__Person_(const Person& value) noexcept {
-    return std__variant_Car__Person_(value);
+  inline std__variant_Person__Car_ create_std__variant_Person__Car_(const Car& value) noexcept {
+    return std__variant_Person__Car_(value);
   }
   
   // pragma MARK: std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper>
@@ -1988,40 +2017,49 @@ namespace margelo::nitro::test::bridge::swift {
     return Result<std::shared_ptr<ArrayBuffer>>::withError(error);
   }
   
-  // pragma MARK: Result<std::variant<std::string, double>>
-  using Result_std__variant_std__string__double__ = Result<std::variant<std::string, double>>;
-  inline Result_std__variant_std__string__double__ create_Result_std__variant_std__string__double__(const std::variant<std::string, double>& value) noexcept {
-    return Result<std::variant<std::string, double>>::withValue(value);
+  // pragma MARK: Result<std::variant<double, std::string>>
+  using Result_std__variant_double__std__string__ = Result<std::variant<double, std::string>>;
+  inline Result_std__variant_double__std__string__ create_Result_std__variant_double__std__string__(const std::variant<double, std::string>& value) noexcept {
+    return Result<std::variant<double, std::string>>::withValue(value);
+  }
+  inline Result_std__variant_double__std__string__ create_Result_std__variant_double__std__string__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<double, std::string>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::variant<OldEnum, bool>>
+  using Result_std__variant_OldEnum__bool__ = Result<std::variant<OldEnum, bool>>;
+  inline Result_std__variant_OldEnum__bool__ create_Result_std__variant_OldEnum__bool__(const std::variant<OldEnum, bool>& value) noexcept {
+    return Result<std::variant<OldEnum, bool>>::withValue(value);
   }
-  inline Result_std__variant_std__string__double__ create_Result_std__variant_std__string__double__(const std::exception_ptr& error) noexcept {
-    return Result<std::variant<std::string, double>>::withError(error);
+  inline Result_std__variant_OldEnum__bool__ create_Result_std__variant_OldEnum__bool__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<OldEnum, bool>>::withError(error);
   }
   
-  // pragma MARK: Result<std::variant<bool, OldEnum>>
-  using Result_std__variant_bool__OldEnum__ = Result<std::variant<bool, OldEnum>>;
-  inline Result_std__variant_bool__OldEnum__ create_Result_std__variant_bool__OldEnum__(const std::variant<bool, OldEnum>& value) noexcept {
-    return Result<std::variant<bool, OldEnum>>::withValue(value);
+  // pragma MARK: Result<std::variant<Powertrain, Car>>
+  using Result_std__variant_Powertrain__Car__ = Result<std::variant<Powertrain, Car>>;
+  inline Result_std__variant_Powertrain__Car__ create_Result_std__variant_Powertrain__Car__(const std::variant<Powertrain, Car>& value) noexcept {
+    return Result<std::variant<Powertrain, Car>>::withValue(value);
   }
-  inline Result_std__variant_bool__OldEnum__ create_Result_std__variant_bool__OldEnum__(const std::exception_ptr& error) noexcept {
-    return Result<std::variant<bool, OldEnum>>::withError(error);
+  inline Result_std__variant_Powertrain__Car__ create_Result_std__variant_Powertrain__Car__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<Powertrain, Car>>::withError(error);
   }
   
-  // pragma MARK: Result<std::variant<bool, WeirdNumbersEnum>>
-  using Result_std__variant_bool__WeirdNumbersEnum__ = Result<std::variant<bool, WeirdNumbersEnum>>;
-  inline Result_std__variant_bool__WeirdNumbersEnum__ create_Result_std__variant_bool__WeirdNumbersEnum__(const std::variant<bool, WeirdNumbersEnum>& value) noexcept {
-    return Result<std::variant<bool, WeirdNumbersEnum>>::withValue(value);
+  // pragma MARK: Result<std::variant<WeirdNumbersEnum, bool>>
+  using Result_std__variant_WeirdNumbersEnum__bool__ = Result<std::variant<WeirdNumbersEnum, bool>>;
+  inline Result_std__variant_WeirdNumbersEnum__bool__ create_Result_std__variant_WeirdNumbersEnum__bool__(const std::variant<WeirdNumbersEnum, bool>& value) noexcept {
+    return Result<std::variant<WeirdNumbersEnum, bool>>::withValue(value);
   }
-  inline Result_std__variant_bool__WeirdNumbersEnum__ create_Result_std__variant_bool__WeirdNumbersEnum__(const std::exception_ptr& error) noexcept {
-    return Result<std::variant<bool, WeirdNumbersEnum>>::withError(error);
+  inline Result_std__variant_WeirdNumbersEnum__bool__ create_Result_std__variant_WeirdNumbersEnum__bool__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<WeirdNumbersEnum, bool>>::withError(error);
   }
   
-  // pragma MARK: Result<std::variant<Car, Person>>
-  using Result_std__variant_Car__Person__ = Result<std::variant<Car, Person>>;
-  inline Result_std__variant_Car__Person__ create_Result_std__variant_Car__Person__(const std::variant<Car, Person>& value) noexcept {
-    return Result<std::variant<Car, Person>>::withValue(value);
+  // pragma MARK: Result<std::variant<Person, Car>>
+  using Result_std__variant_Person__Car__ = Result<std::variant<Person, Car>>;
+  inline Result_std__variant_Person__Car__ create_Result_std__variant_Person__Car__(const std::variant<Person, Car>& value) noexcept {
+    return Result<std::variant<Person, Car>>::withValue(value);
   }
-  inline Result_std__variant_Car__Person__ create_Result_std__variant_Car__Person__(const std::exception_ptr& error) noexcept {
-    return Result<std::variant<Car, Person>>::withError(error);
+  inline Result_std__variant_Person__Car__ create_Result_std__variant_Person__Car__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<Person, Car>>::withError(error);
   }
   
   // pragma MARK: Result<std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper>>
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 a2c103be99..fbba32ad5a 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
@@ -249,11 +249,11 @@ namespace margelo::nitro::test {
     inline void setIsBooleanWritable(bool isBooleanWritable) noexcept override {
       _swiftPart.setIsBooleanWritable(std::forward<decltype(isBooleanWritable)>(isBooleanWritable));
     }
-    inline std::variant<std::string, double> getSomeVariant() noexcept override {
+    inline std::variant<double, std::string> getSomeVariant() noexcept override {
       auto __result = _swiftPart.getSomeVariant();
       return __result;
     }
-    inline void setSomeVariant(const std::variant<std::string, double>& someVariant) noexcept override {
+    inline void setSomeVariant(const std::variant<double, std::string>& someVariant) noexcept override {
       _swiftPart.setSomeVariant(someVariant);
     }
 
@@ -869,7 +869,7 @@ namespace margelo::nitro::test {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::variant<std::string, double> passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& either) override {
+    inline std::variant<double, std::string> passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& either) override {
       auto __result = _swiftPart.passVariant(either);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -877,7 +877,7 @@ namespace margelo::nitro::test {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::variant<bool, OldEnum> getVariantEnum(const std::variant<bool, OldEnum>& variant) override {
+    inline std::variant<OldEnum, bool> getVariantEnum(const std::variant<OldEnum, bool>& variant) override {
       auto __result = _swiftPart.getVariantEnum(variant);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -885,7 +885,15 @@ namespace margelo::nitro::test {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::variant<bool, WeirdNumbersEnum> getVariantWeirdNumbersEnum(const std::variant<bool, WeirdNumbersEnum>& variant) override {
+    inline std::variant<Powertrain, Car> bounceVariantUnionEnum(const std::variant<Powertrain, Car>& variant) override {
+      auto __result = _swiftPart.bounceVariantUnionEnum(variant);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::variant<WeirdNumbersEnum, bool> getVariantWeirdNumbersEnum(const std::variant<WeirdNumbersEnum, bool>& variant) override {
       auto __result = _swiftPart.getVariantWeirdNumbersEnum(variant);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -893,7 +901,7 @@ namespace margelo::nitro::test {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::variant<Car, Person> getVariantObjects(const std::variant<Car, Person>& variant) override {
+    inline std::variant<Person, Car> getVariantObjects(const std::variant<Person, Car>& variant) override {
       auto __result = _swiftPart.getVariantObjects(variant);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Car.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Car.swift
index 82eddc3489..d5e856ca37 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Car.swift
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Car.swift
@@ -18,7 +18,7 @@ public extension Car {
   /**
    * Create a new instance of `Car`.
    */
-  init(year: Double, make: String, model: String, power: Double, powertrain: Powertrain, driver: Person?, passengers: [Person], isFast: Bool?, favouriteTrack: String?, performanceScores: [Double], someVariant: Variant_String_Double?) {
+  init(year: Double, make: String, model: String, power: Double, powertrain: Powertrain, driver: Person?, passengers: [Person], isFast: Bool?, favouriteTrack: String?, performanceScores: [Double], someVariant: Variant_Double_String?) {
     self.init(year, std.string(make), std.string(model), power, powertrain, { () -> bridge.std__optional_Person_ in
       if let __unwrappedValue = driver {
         return bridge.create_std__optional_Person_(__unwrappedValue)
@@ -49,14 +49,14 @@ public extension Car {
         __vector.push_back(__item)
       }
       return __vector
-    }(), { () -> bridge.std__optional_std__variant_std__string__double__ in
+    }(), { () -> bridge.std__optional_std__variant_double__std__string__ in
       if let __unwrappedValue = someVariant {
-        return bridge.create_std__optional_std__variant_std__string__double__({ () -> bridge.std__variant_std__string__double_ in
+        return bridge.create_std__optional_std__variant_double__std__string__({ () -> bridge.std__variant_double__std__string_ in
           switch __unwrappedValue {
             case .first(let __value):
-              return bridge.create_std__variant_std__string__double_(std.string(__value))
+              return bridge.create_std__variant_double__std__string_(__value)
             case .second(let __value):
-              return bridge.create_std__variant_std__string__double_(__value)
+              return bridge.create_std__variant_double__std__string_(std.string(__value))
           }
         }().variant)
       } else {
@@ -130,19 +130,19 @@ public extension Car {
   }
   
   @inline(__always)
-  var someVariant: Variant_String_Double? {
-    return { () -> Variant_String_Double? in
-      if bridge.has_value_std__optional_std__variant_std__string__double__(self.__someVariant) {
-        let __unwrapped = bridge.get_std__optional_std__variant_std__string__double__(self.__someVariant)
-        return { () -> Variant_String_Double in
-          let __variant = bridge.std__variant_std__string__double_(__unwrapped)
+  var someVariant: Variant_Double_String? {
+    return { () -> Variant_Double_String? in
+      if bridge.has_value_std__optional_std__variant_double__std__string__(self.__someVariant) {
+        let __unwrapped = bridge.get_std__optional_std__variant_double__std__string__(self.__someVariant)
+        return { () -> Variant_Double_String in
+          let __variant = bridge.std__variant_double__std__string_(__unwrapped)
           switch __variant.index() {
             case 0:
               let __actual = __variant.get_0()
-              return .first(String(__actual))
+              return .first(__actual)
             case 1:
               let __actual = __variant.get_1()
-              return .second(__actual)
+              return .second(String(__actual))
             default:
               fatalError("Variant can never have index \(__variant.index())!")
           }
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 c29b8679ff..2733834443 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
@@ -30,7 +30,7 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: HybridObject {
   var isBoolean: Bool { get }
   var hasBooleanWritable: Bool { get set }
   var isBooleanWritable: Bool { get set }
-  var someVariant: Variant_String_Double { get set }
+  var someVariant: Variant_Double_String { get set }
 
   // Methods
   func newTestObject() throws -> (any HybridTestObjectSwiftKotlinSpec)
@@ -112,10 +112,11 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: HybridObject {
   func setAllValuesTo(buffer: ArrayBuffer, value: Double) throws -> Void
   func createArrayBufferAsync() throws -> Promise<ArrayBuffer>
   func bounceArrayBuffer(buffer: ArrayBuffer) throws -> ArrayBuffer
-  func passVariant(either: Variant_Bool__Double___String__String_Double) throws -> Variant_String_Double
-  func getVariantEnum(variant: Variant_Bool_OldEnum) throws -> Variant_Bool_OldEnum
-  func getVariantWeirdNumbersEnum(variant: Variant_Bool_WeirdNumbersEnum) throws -> Variant_Bool_WeirdNumbersEnum
-  func getVariantObjects(variant: Variant_Car_Person) throws -> Variant_Car_Person
+  func passVariant(either: Variant_Bool__Double___String__Double_String) throws -> Variant_Double_String
+  func getVariantEnum(variant: Variant_OldEnum_Bool) throws -> Variant_OldEnum_Bool
+  func bounceVariantUnionEnum(variant: Variant_Powertrain_Car) throws -> Variant_Powertrain_Car
+  func getVariantWeirdNumbersEnum(variant: Variant_WeirdNumbersEnum_Bool) throws -> Variant_WeirdNumbersEnum_Bool
+  func getVariantObjects(variant: Variant_Person_Car) throws -> Variant_Person_Car
   func passNamedVariant(variant: NamedVariant) throws -> NamedVariant
   func passAllEmptyObjectVariant(variant: Variant__any_HybridBaseSpec__OptionalWrapper) throws -> Variant__any_HybridBaseSpec__OptionalWrapper
   func bounceComplexVariant(variant: CoreTypesVariant) throws -> CoreTypesVariant
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 af4ba7b2de..917c6ba46e 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
@@ -439,29 +439,29 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
     }
   }
   
-  public final var someVariant: bridge.std__variant_std__string__double_ {
+  public final var someVariant: bridge.std__variant_double__std__string_ {
     @inline(__always)
     get {
-      return { () -> bridge.std__variant_std__string__double_ in
+      return { () -> bridge.std__variant_double__std__string_ in
         switch self.__implementation.someVariant {
           case .first(let __value):
-            return bridge.create_std__variant_std__string__double_(std.string(__value))
+            return bridge.create_std__variant_double__std__string_(__value)
           case .second(let __value):
-            return bridge.create_std__variant_std__string__double_(__value)
+            return bridge.create_std__variant_double__std__string_(std.string(__value))
         }
       }()
     }
     @inline(__always)
     set {
-      self.__implementation.someVariant = { () -> Variant_String_Double in
+      self.__implementation.someVariant = { () -> Variant_Double_String in
         let __variant = newValue
         switch __variant.index() {
           case 0:
             let __actual = __variant.get_0()
-            return .first(String(__actual))
+            return .first(__actual)
           case 1:
             let __actual = __variant.get_1()
-            return .second(__actual)
+            return .second(String(__actual))
           default:
             fatalError("Variant can never have index \(__variant.index())!")
         }
@@ -2093,9 +2093,9 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
   }
   
   @inline(__always)
-  public final func passVariant(either: bridge.std__variant_bool__std__vector_double___std__vector_std__string___std__string__double_) -> bridge.Result_std__variant_std__string__double__ {
+  public final func passVariant(either: bridge.std__variant_bool__std__vector_double___std__vector_std__string___double__std__string_) -> bridge.Result_std__variant_double__std__string__ {
     do {
-      let __result = try self.__implementation.passVariant(either: { () -> Variant_Bool__Double___String__String_Double in
+      let __result = try self.__implementation.passVariant(either: { () -> Variant_Bool__Double___String__Double_String in
         let __variant = either
         switch __variant.index() {
           case 0:
@@ -2109,33 +2109,64 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
             return .third(__actual.map({ __item in String(__item) }))
           case 3:
             let __actual = __variant.get_3()
-            return .fourth(String(__actual))
+            return .fourth(__actual)
           case 4:
             let __actual = __variant.get_4()
-            return .fifth(__actual)
+            return .fifth(String(__actual))
+          default:
+            fatalError("Variant can never have index \(__variant.index())!")
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__variant_double__std__string_ in
+        switch __result {
+          case .first(let __value):
+            return bridge.create_std__variant_double__std__string_(__value)
+          case .second(let __value):
+            return bridge.create_std__variant_double__std__string_(std.string(__value))
+        }
+      }().variant
+      return bridge.create_Result_std__variant_double__std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__variant_double__std__string__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getVariantEnum(variant: bridge.std__variant_OldEnum__bool_) -> bridge.Result_std__variant_OldEnum__bool__ {
+    do {
+      let __result = try self.__implementation.getVariantEnum(variant: { () -> Variant_OldEnum_Bool in
+        let __variant = variant
+        switch __variant.index() {
+          case 0:
+            let __actual = __variant.get_0()
+            return .first(__actual)
+          case 1:
+            let __actual = __variant.get_1()
+            return .second(__actual)
           default:
             fatalError("Variant can never have index \(__variant.index())!")
         }
       }())
-      let __resultCpp = { () -> bridge.std__variant_std__string__double_ in
+      let __resultCpp = { () -> bridge.std__variant_OldEnum__bool_ in
         switch __result {
           case .first(let __value):
-            return bridge.create_std__variant_std__string__double_(std.string(__value))
+            return bridge.create_std__variant_OldEnum__bool_(__value)
           case .second(let __value):
-            return bridge.create_std__variant_std__string__double_(__value)
+            return bridge.create_std__variant_OldEnum__bool_(__value)
         }
       }().variant
-      return bridge.create_Result_std__variant_std__string__double__(__resultCpp)
+      return bridge.create_Result_std__variant_OldEnum__bool__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__variant_std__string__double__(__exceptionPtr)
+      return bridge.create_Result_std__variant_OldEnum__bool__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func getVariantEnum(variant: bridge.std__variant_bool__OldEnum_) -> bridge.Result_std__variant_bool__OldEnum__ {
+  public final func bounceVariantUnionEnum(variant: bridge.std__variant_Powertrain__Car_) -> bridge.Result_std__variant_Powertrain__Car__ {
     do {
-      let __result = try self.__implementation.getVariantEnum(variant: { () -> Variant_Bool_OldEnum in
+      let __result = try self.__implementation.bounceVariantUnionEnum(variant: { () -> Variant_Powertrain_Car in
         let __variant = variant
         switch __variant.index() {
           case 0:
@@ -2148,25 +2179,25 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
             fatalError("Variant can never have index \(__variant.index())!")
         }
       }())
-      let __resultCpp = { () -> bridge.std__variant_bool__OldEnum_ in
+      let __resultCpp = { () -> bridge.std__variant_Powertrain__Car_ in
         switch __result {
           case .first(let __value):
-            return bridge.create_std__variant_bool__OldEnum_(__value)
+            return bridge.create_std__variant_Powertrain__Car_(__value)
           case .second(let __value):
-            return bridge.create_std__variant_bool__OldEnum_(__value)
+            return bridge.create_std__variant_Powertrain__Car_(__value)
         }
       }().variant
-      return bridge.create_Result_std__variant_bool__OldEnum__(__resultCpp)
+      return bridge.create_Result_std__variant_Powertrain__Car__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__variant_bool__OldEnum__(__exceptionPtr)
+      return bridge.create_Result_std__variant_Powertrain__Car__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func getVariantWeirdNumbersEnum(variant: bridge.std__variant_bool__WeirdNumbersEnum_) -> bridge.Result_std__variant_bool__WeirdNumbersEnum__ {
+  public final func getVariantWeirdNumbersEnum(variant: bridge.std__variant_WeirdNumbersEnum__bool_) -> bridge.Result_std__variant_WeirdNumbersEnum__bool__ {
     do {
-      let __result = try self.__implementation.getVariantWeirdNumbersEnum(variant: { () -> Variant_Bool_WeirdNumbersEnum in
+      let __result = try self.__implementation.getVariantWeirdNumbersEnum(variant: { () -> Variant_WeirdNumbersEnum_Bool in
         let __variant = variant
         switch __variant.index() {
           case 0:
@@ -2179,25 +2210,25 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
             fatalError("Variant can never have index \(__variant.index())!")
         }
       }())
-      let __resultCpp = { () -> bridge.std__variant_bool__WeirdNumbersEnum_ in
+      let __resultCpp = { () -> bridge.std__variant_WeirdNumbersEnum__bool_ in
         switch __result {
           case .first(let __value):
-            return bridge.create_std__variant_bool__WeirdNumbersEnum_(__value)
+            return bridge.create_std__variant_WeirdNumbersEnum__bool_(__value)
           case .second(let __value):
-            return bridge.create_std__variant_bool__WeirdNumbersEnum_(__value)
+            return bridge.create_std__variant_WeirdNumbersEnum__bool_(__value)
         }
       }().variant
-      return bridge.create_Result_std__variant_bool__WeirdNumbersEnum__(__resultCpp)
+      return bridge.create_Result_std__variant_WeirdNumbersEnum__bool__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__variant_bool__WeirdNumbersEnum__(__exceptionPtr)
+      return bridge.create_Result_std__variant_WeirdNumbersEnum__bool__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func getVariantObjects(variant: bridge.std__variant_Car__Person_) -> bridge.Result_std__variant_Car__Person__ {
+  public final func getVariantObjects(variant: bridge.std__variant_Person__Car_) -> bridge.Result_std__variant_Person__Car__ {
     do {
-      let __result = try self.__implementation.getVariantObjects(variant: { () -> Variant_Car_Person in
+      let __result = try self.__implementation.getVariantObjects(variant: { () -> Variant_Person_Car in
         let __variant = variant
         switch __variant.index() {
           case 0:
@@ -2210,18 +2241,18 @@ open class HybridTestObjectSwiftKotlinSpec_cxx {
             fatalError("Variant can never have index \(__variant.index())!")
         }
       }())
-      let __resultCpp = { () -> bridge.std__variant_Car__Person_ in
+      let __resultCpp = { () -> bridge.std__variant_Person__Car_ in
         switch __result {
           case .first(let __value):
-            return bridge.create_std__variant_Car__Person_(__value)
+            return bridge.create_std__variant_Person__Car_(__value)
           case .second(let __value):
-            return bridge.create_std__variant_Car__Person_(__value)
+            return bridge.create_std__variant_Person__Car_(__value)
         }
       }().variant
-      return bridge.create_Result_std__variant_Car__Person__(__resultCpp)
+      return bridge.create_Result_std__variant_Person__Car__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__variant_Car__Person__(__exceptionPtr)
+      return bridge.create_Result_std__variant_Person__Car__(__exceptionPtr)
     }
   }
   
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool__Double___String__String_Double.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool__Double___String__Double_String.swift
similarity index 71%
rename from packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool__Double___String__String_Double.swift
rename to packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool__Double___String__Double_String.swift
index 0ed7bdbfcc..ce12aff033 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool__Double___String__String_Double.swift
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool__Double___String__Double_String.swift
@@ -1,5 +1,5 @@
 ///
-/// Variant_Bool__Double___String__String_Double.swift
+/// Variant_Bool__Double___String__Double_String.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -9,18 +9,18 @@
 
 /**
  * An Swift enum with associated values representing a Variant/Union type.
- * JS type: `boolean | array | array | string | number`
+ * JS type: `boolean | array | array | number | string`
  */
 @frozen
-public indirect enum Variant_Bool__Double___String__String_Double {
+public indirect enum Variant_Bool__Double___String__Double_String {
   case first(Bool)
   case second([Double])
   case third([String])
-  case fourth(String)
-  case fifth(Double)
+  case fourth(Double)
+  case fifth(String)
 }
 
-public extension Variant_Bool__Double___String__String_Double {
+public extension Variant_Bool__Double___String__Double_String {
   func asType<T>(_ type: T.Type = T.self) -> T? {
     switch self {
       case .first(let value): return value as? T
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_String_Double.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Double_String.swift
similarity index 74%
rename from packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_String_Double.swift
rename to packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Double_String.swift
index 6c5e61332c..a818cde9a7 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_String_Double.swift
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Double_String.swift
@@ -1,5 +1,5 @@
 ///
-/// Variant_String_Double.swift
+/// Variant_Double_String.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -9,15 +9,15 @@
 
 /**
  * An Swift enum with associated values representing a Variant/Union type.
- * JS type: `string | number`
+ * JS type: `number | string`
  */
 @frozen
-public enum Variant_String_Double {
-  case first(String)
-  case second(Double)
+public enum Variant_Double_String {
+  case first(Double)
+  case second(String)
 }
 
-public extension Variant_String_Double {
+public extension Variant_Double_String {
   func asType<T>(_ type: T.Type = T.self) -> T? {
     switch self {
       case .first(let value): return value as? T
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool_OldEnum.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_OldEnum_Bool.swift
similarity index 73%
rename from packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool_OldEnum.swift
rename to packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_OldEnum_Bool.swift
index dd01bd8f75..74597a269c 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool_OldEnum.swift
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_OldEnum_Bool.swift
@@ -1,5 +1,5 @@
 ///
-/// Variant_Bool_OldEnum.swift
+/// Variant_OldEnum_Bool.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -9,15 +9,15 @@
 
 /**
  * An Swift enum with associated values representing a Variant/Union type.
- * JS type: `boolean | enum`
+ * JS type: `enum | boolean`
  */
 @frozen
-public indirect enum Variant_Bool_OldEnum {
-  case first(Bool)
-  case second(OldEnum)
+public indirect enum Variant_OldEnum_Bool {
+  case first(OldEnum)
+  case second(Bool)
 }
 
-public extension Variant_Bool_OldEnum {
+public extension Variant_OldEnum_Bool {
   func asType<T>(_ type: T.Type = T.self) -> T? {
     switch self {
       case .first(let value): return value as? T
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Car_Person.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Person_Car.swift
similarity index 78%
rename from packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Car_Person.swift
rename to packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Person_Car.swift
index 18e77e51c1..d2767fb6be 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Car_Person.swift
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Person_Car.swift
@@ -1,5 +1,5 @@
 ///
-/// Variant_Car_Person.swift
+/// Variant_Person_Car.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -12,12 +12,12 @@
  * JS type: `struct | struct`
  */
 @frozen
-public indirect enum Variant_Car_Person {
-  case first(Car)
-  case second(Person)
+public indirect enum Variant_Person_Car {
+  case first(Person)
+  case second(Car)
 }
 
-public extension Variant_Car_Person {
+public extension Variant_Person_Car {
   func asType<T>(_ type: T.Type = T.self) -> T? {
     switch self {
       case .first(let value): return value as? T
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool_WeirdNumbersEnum.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Powertrain_Car.swift
similarity index 70%
rename from packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool_WeirdNumbersEnum.swift
rename to packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Powertrain_Car.swift
index c16b611982..8dbd0a78f3 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Bool_WeirdNumbersEnum.swift
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_Powertrain_Car.swift
@@ -1,5 +1,5 @@
 ///
-/// Variant_Bool_WeirdNumbersEnum.swift
+/// Variant_Powertrain_Car.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -9,15 +9,15 @@
 
 /**
  * An Swift enum with associated values representing a Variant/Union type.
- * JS type: `boolean | enum`
+ * JS type: `enum | struct`
  */
 @frozen
-public indirect enum Variant_Bool_WeirdNumbersEnum {
-  case first(Bool)
-  case second(WeirdNumbersEnum)
+public indirect enum Variant_Powertrain_Car {
+  case first(Powertrain)
+  case second(Car)
 }
 
-public extension Variant_Bool_WeirdNumbersEnum {
+public extension Variant_Powertrain_Car {
   func asType<T>(_ type: T.Type = T.self) -> T? {
     switch self {
       case .first(let value): return value as? T
diff --git a/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_WeirdNumbersEnum_Bool.swift b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_WeirdNumbersEnum_Bool.swift
new file mode 100644
index 0000000000..d66e768f15
--- /dev/null
+++ b/packages/react-native-nitro-test/nitrogen/generated/ios/swift/Variant_WeirdNumbersEnum_Bool.swift
@@ -0,0 +1,30 @@
+///
+/// Variant_WeirdNumbersEnum_Bool.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+
+
+/**
+ * An Swift enum with associated values representing a Variant/Union type.
+ * JS type: `enum | boolean`
+ */
+@frozen
+public indirect enum Variant_WeirdNumbersEnum_Bool {
+  case first(WeirdNumbersEnum)
+  case second(Bool)
+}
+
+public extension Variant_WeirdNumbersEnum_Bool {
+  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
+  }
+}
diff --git a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/Car.hpp b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/Car.hpp
index 01dbc28c68..471e4e6a0b 100644
--- a/packages/react-native-nitro-test/nitrogen/generated/shared/c++/Car.hpp
+++ b/packages/react-native-nitro-test/nitrogen/generated/shared/c++/Car.hpp
@@ -57,11 +57,11 @@ namespace margelo::nitro::test {
     std::optional<bool> isFast     SWIFT_PRIVATE;
     std::optional<std::string> favouriteTrack     SWIFT_PRIVATE;
     std::vector<double> performanceScores     SWIFT_PRIVATE;
-    std::optional<std::variant<std::string, double>> someVariant     SWIFT_PRIVATE;
+    std::optional<std::variant<double, std::string>> someVariant     SWIFT_PRIVATE;
 
   public:
     Car() = default;
-    explicit Car(double year, std::string make, std::string model, double power, Powertrain powertrain, std::optional<Person> driver, std::vector<Person> passengers, std::optional<bool> isFast, std::optional<std::string> favouriteTrack, std::vector<double> performanceScores, std::optional<std::variant<std::string, double>> someVariant): year(year), make(make), model(model), power(power), powertrain(powertrain), driver(driver), passengers(passengers), isFast(isFast), favouriteTrack(favouriteTrack), performanceScores(performanceScores), someVariant(someVariant) {}
+    explicit Car(double year, std::string make, std::string model, double power, Powertrain powertrain, std::optional<Person> driver, std::vector<Person> passengers, std::optional<bool> isFast, std::optional<std::string> favouriteTrack, std::vector<double> performanceScores, std::optional<std::variant<double, std::string>> someVariant): year(year), make(make), model(model), power(power), powertrain(powertrain), driver(driver), passengers(passengers), isFast(isFast), favouriteTrack(favouriteTrack), performanceScores(performanceScores), someVariant(someVariant) {}
 
   public:
     friend bool operator==(const Car& lhs, const Car& rhs) = default;
@@ -87,7 +87,7 @@ namespace margelo::nitro {
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isFast"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "favouriteTrack"))),
         JSIConverter<std::vector<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "performanceScores"))),
-        JSIConverter<std::optional<std::variant<std::string, double>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "someVariant")))
+        JSIConverter<std::optional<std::variant<double, std::string>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "someVariant")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::test::Car& arg) {
@@ -102,7 +102,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "isFast"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.isFast));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "favouriteTrack"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.favouriteTrack));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "performanceScores"), JSIConverter<std::vector<double>>::toJSI(runtime, arg.performanceScores));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "someVariant"), JSIConverter<std::optional<std::variant<std::string, double>>>::toJSI(runtime, arg.someVariant));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "someVariant"), JSIConverter<std::optional<std::variant<double, std::string>>>::toJSI(runtime, arg.someVariant));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -123,7 +123,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isFast")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "favouriteTrack")))) return false;
       if (!JSIConverter<std::vector<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "performanceScores")))) return false;
-      if (!JSIConverter<std::optional<std::variant<std::string, double>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "someVariant")))) return false;
+      if (!JSIConverter<std::optional<std::variant<double, std::string>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "someVariant")))) return false;
       return true;
     }
   };
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 806e6b20a1..daad8048b8 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
@@ -59,6 +59,7 @@ namespace margelo::nitro::test {
       prototype.registerHybridMethod("newTestObject", &HybridTestObjectCppSpec::newTestObject);
       prototype.registerHybridMethod("newTestObjectAsync", &HybridTestObjectCppSpec::newTestObjectAsync);
       prototype.registerHybridMethod("getVariantHybrid", &HybridTestObjectCppSpec::getVariantHybrid);
+      prototype.registerHybridMethod("getVariantHybridEnum", &HybridTestObjectCppSpec::getVariantHybridEnum);
       prototype.registerHybridMethod("bounceAnyHybrid", &HybridTestObjectCppSpec::bounceAnyHybrid);
       prototype.registerHybridMethod("bounceCustomType", &HybridTestObjectCppSpec::bounceCustomType);
       prototype.registerHybridMethod("simpleFunc", &HybridTestObjectCppSpec::simpleFunc);
@@ -139,6 +140,7 @@ namespace margelo::nitro::test {
       prototype.registerHybridMethod("bounceArrayBuffer", &HybridTestObjectCppSpec::bounceArrayBuffer);
       prototype.registerHybridMethod("passVariant", &HybridTestObjectCppSpec::passVariant);
       prototype.registerHybridMethod("getVariantEnum", &HybridTestObjectCppSpec::getVariantEnum);
+      prototype.registerHybridMethod("bounceVariantUnionEnum", &HybridTestObjectCppSpec::bounceVariantUnionEnum);
       prototype.registerHybridMethod("getVariantWeirdNumbersEnum", &HybridTestObjectCppSpec::getVariantWeirdNumbersEnum);
       prototype.registerHybridMethod("getVariantObjects", &HybridTestObjectCppSpec::getVariantObjects);
       prototype.registerHybridMethod("passNamedVariant", &HybridTestObjectCppSpec::passNamedVariant);
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 18752e14f9..f0b55484a8 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
@@ -151,8 +151,8 @@ namespace margelo::nitro::test {
       virtual void setHasBooleanWritable(bool hasBooleanWritable) = 0;
       virtual bool getIsBooleanWritable() = 0;
       virtual void setIsBooleanWritable(bool isBooleanWritable) = 0;
-      virtual std::variant<std::string, double> getSomeVariant() = 0;
-      virtual void setSomeVariant(const std::variant<std::string, double>& someVariant) = 0;
+      virtual std::variant<double, std::string> getSomeVariant() = 0;
+      virtual void setSomeVariant(const std::variant<double, std::string>& someVariant) = 0;
 
     public:
       // Methods
@@ -162,6 +162,7 @@ namespace margelo::nitro::test {
       virtual std::shared_ptr<HybridTestObjectCppSpec> newTestObject() = 0;
       virtual std::shared_ptr<Promise<std::shared_ptr<HybridTestObjectCppSpec>>> newTestObjectAsync() = 0;
       virtual std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Person> getVariantHybrid(const std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Person>& variant) = 0;
+      virtual std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Powertrain> getVariantHybridEnum(const std::variant<std::shared_ptr<HybridTestObjectCppSpec>, Powertrain>& variant) = 0;
       virtual std::shared_ptr<HybridObject> bounceAnyHybrid(const std::shared_ptr<HybridObject>& object) = 0;
       virtual CustomString bounceCustomType(CustomString value) = 0;
       virtual void simpleFunc() = 0;
@@ -240,10 +241,11 @@ namespace margelo::nitro::test {
       virtual void setAllValuesTo(const std::shared_ptr<ArrayBuffer>& buffer, double value) = 0;
       virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> createArrayBufferAsync() = 0;
       virtual std::shared_ptr<ArrayBuffer> bounceArrayBuffer(const std::shared_ptr<ArrayBuffer>& buffer) = 0;
-      virtual std::variant<std::string, double> passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& either) = 0;
-      virtual std::variant<bool, OldEnum> getVariantEnum(const std::variant<bool, OldEnum>& variant) = 0;
-      virtual std::variant<bool, WeirdNumbersEnum> getVariantWeirdNumbersEnum(const std::variant<bool, WeirdNumbersEnum>& variant) = 0;
-      virtual std::variant<Car, Person> getVariantObjects(const std::variant<Car, Person>& variant) = 0;
+      virtual std::variant<double, std::string> passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& either) = 0;
+      virtual std::variant<OldEnum, bool> getVariantEnum(const std::variant<OldEnum, bool>& variant) = 0;
+      virtual std::variant<Powertrain, Car> bounceVariantUnionEnum(const std::variant<Powertrain, Car>& variant) = 0;
+      virtual std::variant<WeirdNumbersEnum, bool> getVariantWeirdNumbersEnum(const std::variant<WeirdNumbersEnum, bool>& variant) = 0;
+      virtual std::variant<Person, Car> getVariantObjects(const std::variant<Person, Car>& variant) = 0;
       virtual std::variant<std::string, Car> passNamedVariant(const std::variant<std::string, Car>& variant) = 0;
       virtual std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper> passAllEmptyObjectVariant(const std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper>& variant) = 0;
       virtual std::variant<std::shared_ptr<ArrayBuffer>, std::function<void(double /* value */)>, WrappedJsStruct, std::shared_ptr<Promise<double>>, std::chrono::system_clock::time_point, std::shared_ptr<AnyMap>> bounceComplexVariant(const std::variant<std::shared_ptr<ArrayBuffer>, std::function<void(double /* value */)>, WrappedJsStruct, std::shared_ptr<Promise<double>>, std::chrono::system_clock::time_point, std::shared_ptr<AnyMap>>& variant) = 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 9eda818d2c..785c00f31e 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
@@ -132,6 +132,7 @@ namespace margelo::nitro::test {
       prototype.registerHybridMethod("bounceArrayBuffer", &HybridTestObjectSwiftKotlinSpec::bounceArrayBuffer);
       prototype.registerHybridMethod("passVariant", &HybridTestObjectSwiftKotlinSpec::passVariant);
       prototype.registerHybridMethod("getVariantEnum", &HybridTestObjectSwiftKotlinSpec::getVariantEnum);
+      prototype.registerHybridMethod("bounceVariantUnionEnum", &HybridTestObjectSwiftKotlinSpec::bounceVariantUnionEnum);
       prototype.registerHybridMethod("getVariantWeirdNumbersEnum", &HybridTestObjectSwiftKotlinSpec::getVariantWeirdNumbersEnum);
       prototype.registerHybridMethod("getVariantObjects", &HybridTestObjectSwiftKotlinSpec::getVariantObjects);
       prototype.registerHybridMethod("passNamedVariant", &HybridTestObjectSwiftKotlinSpec::passNamedVariant);
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 675c38a6db..ae57b20c05 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
@@ -144,8 +144,8 @@ namespace margelo::nitro::test {
       virtual void setHasBooleanWritable(bool hasBooleanWritable) = 0;
       virtual bool getIsBooleanWritable() = 0;
       virtual void setIsBooleanWritable(bool isBooleanWritable) = 0;
-      virtual std::variant<std::string, double> getSomeVariant() = 0;
-      virtual void setSomeVariant(const std::variant<std::string, double>& someVariant) = 0;
+      virtual std::variant<double, std::string> getSomeVariant() = 0;
+      virtual void setSomeVariant(const std::variant<double, std::string>& someVariant) = 0;
 
     public:
       // Methods
@@ -228,10 +228,11 @@ namespace margelo::nitro::test {
       virtual void setAllValuesTo(const std::shared_ptr<ArrayBuffer>& buffer, double value) = 0;
       virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> createArrayBufferAsync() = 0;
       virtual std::shared_ptr<ArrayBuffer> bounceArrayBuffer(const std::shared_ptr<ArrayBuffer>& buffer) = 0;
-      virtual std::variant<std::string, double> passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, std::string, double>& either) = 0;
-      virtual std::variant<bool, OldEnum> getVariantEnum(const std::variant<bool, OldEnum>& variant) = 0;
-      virtual std::variant<bool, WeirdNumbersEnum> getVariantWeirdNumbersEnum(const std::variant<bool, WeirdNumbersEnum>& variant) = 0;
-      virtual std::variant<Car, Person> getVariantObjects(const std::variant<Car, Person>& variant) = 0;
+      virtual std::variant<double, std::string> passVariant(const std::variant<bool, std::vector<double>, std::vector<std::string>, double, std::string>& either) = 0;
+      virtual std::variant<OldEnum, bool> getVariantEnum(const std::variant<OldEnum, bool>& variant) = 0;
+      virtual std::variant<Powertrain, Car> bounceVariantUnionEnum(const std::variant<Powertrain, Car>& variant) = 0;
+      virtual std::variant<WeirdNumbersEnum, bool> getVariantWeirdNumbersEnum(const std::variant<WeirdNumbersEnum, bool>& variant) = 0;
+      virtual std::variant<Person, Car> getVariantObjects(const std::variant<Person, Car>& variant) = 0;
       virtual std::variant<std::string, Car> passNamedVariant(const std::variant<std::string, Car>& variant) = 0;
       virtual std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper> passAllEmptyObjectVariant(const std::variant<std::shared_ptr<HybridBaseSpec>, OptionalWrapper>& variant) = 0;
       virtual std::variant<std::shared_ptr<ArrayBuffer>, std::function<void(double /* value */)>, WrappedJsStruct, std::shared_ptr<Promise<double>>, std::chrono::system_clock::time_point, std::shared_ptr<AnyMap>> bounceComplexVariant(const std::variant<std::shared_ptr<ArrayBuffer>, std::function<void(double /* value */)>, WrappedJsStruct, std::shared_ptr<Promise<double>>, std::chrono::system_clock::time_point, std::shared_ptr<AnyMap>>& variant) = 0;
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 02eefa16bb..1afe8ef17e 100644
--- a/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts
+++ b/packages/react-native-nitro-test/src/specs/TestObject.nitro.ts
@@ -288,6 +288,7 @@ interface SharedTestObjectProps {
     either: number | string | number[] | string[] | boolean
   ): number | string
   getVariantEnum(variant: OldEnum | boolean): OldEnum | boolean
+  bounceVariantUnionEnum(variant: Powertrain | Car): Powertrain | Car
   getVariantWeirdNumbersEnum(
     variant: WeirdNumbersEnum | boolean
   ): WeirdNumbersEnum | boolean
@@ -346,6 +347,9 @@ export interface TestObjectCpp
   newTestObjectAsync(): Promise<TestObjectCpp>
   optionalHybrid?: TestObjectCpp
   getVariantHybrid(variant: TestObjectCpp | Person): TestObjectCpp | Person
+  getVariantHybridEnum(
+    variant: TestObjectCpp | Powertrain
+  ): TestObjectCpp | Powertrain
 
   // Any HybridObject
   bounceAnyHybrid(object: AnyHybridObject): AnyHybridObject