react-native-acoustic-connect-beta 18.0.18 → 18.0.20

package/nitrogen/generated/android/c++/JVariant_NullType_String.cpp

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_String.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JVariant_NullType_String.hpp"
+
+namespace margelo::nitro::acousticconnectrn {
+  /**
+   * Converts JVariant_NullType_String to std::variant<nitro::NullType, std::string>
+   */
+  std::variant<nitro::NullType, std::string> JVariant_NullType_String::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_String_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_String_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_String_impl::Second::javaClassStatic())) {
+      // It's a `std::string`
+      auto jniValue = static_cast<const JVariant_NullType_String_impl::Second*>(this)->getValue();
+      return jniValue->toStdString();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::acousticconnectrn

package/nitrogen/generated/android/c++/JVariant_NullType_String.hpp

@@ -0,0 +1,70 @@
+///
+/// JVariant_NullType_String.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 <NitroModules/Null.hpp>
+#include <string>
+#include <variant>
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::acousticconnectrn {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_String".
+   */
+  class JVariant_NullType_String: public jni::JavaClass<JVariant_NullType_String> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/Variant_NullType_String;";
+
+    static jni::local_ref<JVariant_NullType_String> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_String(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_String> create_1(jni::alias_ref<jni::JString> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_String(jni::alias_ref<jni::JString>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_String> fromCpp(const std::variant<nitro::NullType, std::string>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        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<nitro::NullType, std::string> toCpp() const;
+  };
+
+  namespace JVariant_NullType_String_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_String> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/Variant_NullType_String$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JVariant_NullType_String> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/acousticconnectrn/Variant_NullType_String$Second;";
+    
+      [[nodiscard]] jni::local_ref<jni::JString> getValue() const {
+        static const auto field = javaClassStatic()->getField<jni::JString>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_String_impl
+} // namespace margelo::nitro::acousticconnectrn

package/nitrogen/generated/android/kotlin/com/margelo/nitro/acousticconnectrn/AcousticConnectRNOnLoad.kt

@@ -2,7 +2,7 @@
 /// AcousticConnectRNOnLoad.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 package com.margelo.nitro.acousticconnectrn

package/nitrogen/generated/android/kotlin/com/margelo/nitro/acousticconnectrn/HybridAcousticConnectRNSpec.kt

@@ -2,7 +2,7 @@
 /// HybridAcousticConnectRNSpec.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 package com.margelo.nitro.acousticconnectrn
@@ -10,7 +10,8 @@ package com.margelo.nitro.acousticconnectrn
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
-import com.margelo.nitro.core.*
+import com.margelo.nitro.core.NullType
+import com.margelo.nitro.core.HybridObject
 
 /**
  * A Kotlin class representing the AcousticConnectRN HybridObject.
@@ -24,18 +25,6 @@ import com.margelo.nitro.core.*
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
 abstract class HybridAcousticConnectRNSpec: HybridObject() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    super.updateNative(mHybridData)
-  }
-
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-    super.updateNative(hybridData)
-  }
-
   // Properties
   
 
@@ -54,7 +43,7 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun setConfigItemForKey(key: String, value: Variant_String_Double_Boolean, moduleName: String): Boolean
+  abstract fun setConfigItemForKey(key: String, value: Variant_Boolean_String_Double, moduleName: String): Boolean
   
   @DoNotStrip
   @Keep
@@ -62,7 +51,7 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun getStringItemForKey(theDefault: String, key: String, moduleName: String): String?
+  abstract fun getStringItemForKey(theDefault: String, key: String, moduleName: String): Variant_NullType_String?
   
   @DoNotStrip
   @Keep
@@ -70,11 +59,11 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun logCustomEvent(eventName: String, values: Map<String, Variant_String_Double_Boolean>, level: Double): Boolean
+  abstract fun logCustomEvent(eventName: String, values: Map<String, Variant_Boolean_String_Double>, level: Double): Boolean
   
   @DoNotStrip
   @Keep
-  abstract fun logSignal(values: Map<String, Variant_String_Double_Boolean>, level: Double): Boolean
+  abstract fun logSignal(values: Map<String, Variant_Boolean_String_Double>, level: Double): Boolean
   
   @DoNotStrip
   @Keep
@@ -94,7 +83,7 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun logTextChangeEvent(target: Double, controlId: String, text: String?): Boolean
+  abstract fun logTextChangeEvent(target: Double, controlId: String, text: Variant_NullType_String?): Boolean
   
   @DoNotStrip
   @Keep
@@ -102,11 +91,11 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun logScreenViewContextLoad(logicalPageName: String?, referrer: String?): Boolean
+  abstract fun logScreenViewContextLoad(logicalPageName: Variant_NullType_String?, referrer: Variant_NullType_String?): Boolean
   
   @DoNotStrip
   @Keep
-  abstract fun logScreenViewContextUnload(logicalPageName: String?, referrer: String?): Boolean
+  abstract fun logScreenViewContextUnload(logicalPageName: Variant_NullType_String?, referrer: Variant_NullType_String?): Boolean
   
   @DoNotStrip
   @Keep
@@ -126,11 +115,25 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun logDialogCustomEvent(dialogId: String, eventName: String, values: Map<String, Variant_String_Double_Boolean>): Boolean
+  abstract fun logDialogCustomEvent(dialogId: String, eventName: String, values: Map<String, Variant_Boolean_String_Double>): Boolean
 
-  private external fun initHybrid(): HybridData
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject AcousticConnectRN]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridAcousticConnectRNSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridAcousticConnectRNSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
 
   companion object {
-    private const val TAG = "HybridAcousticConnectRNSpec"
+    protected const val TAG = "HybridAcousticConnectRNSpec"
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/acousticconnectrn/Variant_Boolean_String_Double.kt

@@ -0,0 +1,75 @@
+///
+/// Variant_Boolean_String_Double.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.acousticconnectrn
+
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the TypeScript variant "Boolean | String | Double".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class Variant_Boolean_String_Double {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: Boolean): Variant_Boolean_String_Double()
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: String): Variant_Boolean_String_Double()
+  @DoNotStrip
+  data class Third(@DoNotStrip val value: Double): Variant_Boolean_String_Double()
+
+  inline fun <reified T> asType(): T? {
+    return when (this) {
+      is First -> (value) as? T
+      is Second -> (value) as? T
+      is Third -> (value) as? T
+    }
+  }
+  inline fun <reified T> isType(): Boolean {
+    return asType<T>() != null
+  }
+  inline fun <R> match(first: (Boolean) -> R, second: (String) -> R, third: (Double) -> R): R {
+    return when (this) {
+      is First -> first(value)
+      is Second -> second(value)
+      is Third -> third(value)
+    }
+  }
+
+  val isFirst: Boolean
+    get() = this is First
+  val isSecond: Boolean
+    get() = this is Second
+  val isThird: Boolean
+    get() = this is Third
+
+  fun asFirstOrNull(): Boolean? {
+    val value = (this as? First)?.value ?: return null
+    return value
+  }
+  fun asSecondOrNull(): String? {
+    val value = (this as? Second)?.value ?: return null
+    return value
+  }
+  fun asThirdOrNull(): Double? {
+    val value = (this as? Third)?.value ?: return null
+    return value
+  }
+
+  companion object {
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: Boolean): Variant_Boolean_String_Double = First(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: String): Variant_Boolean_String_Double = Second(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: Double): Variant_Boolean_String_Double = Third(value)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/acousticconnectrn/Variant_NullType_String.kt

@@ -0,0 +1,62 @@
+///
+/// Variant_NullType_String.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.acousticconnectrn
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.NullType
+
+/**
+ * Represents the TypeScript variant "NullType | String".
+ */
+@Suppress("ClassName")
+@DoNotStrip
+sealed class Variant_NullType_String {
+  @DoNotStrip
+  data class First(@DoNotStrip val value: NullType): Variant_NullType_String()
+  @DoNotStrip
+  data class Second(@DoNotStrip val value: String): Variant_NullType_String()
+
+  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: (NullType) -> R, second: (String) -> R): R {
+    return when (this) {
+      is First -> first(value)
+      is Second -> second(value)
+    }
+  }
+
+  val isFirst: Boolean
+    get() = this is First
+  val isSecond: Boolean
+    get() = this is Second
+
+  fun asFirstOrNull(): NullType? {
+    val value = (this as? First)?.value ?: return null
+    return value
+  }
+  fun asSecondOrNull(): String? {
+    val value = (this as? Second)?.value ?: return null
+    return value
+  }
+
+  companion object {
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: NullType): Variant_NullType_String = First(value)
+    @JvmStatic
+    @DoNotStrip
+    fun create(value: String): Variant_NullType_String = Second(value)
+  }
+}

package/nitrogen/generated/ios/AcousticConnectRN+autolinking.rb

@@ -2,7 +2,7 @@
 # AcousticConnectRN+autolinking.rb
 # This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 # https://github.com/mrousavy/nitro
-# Copyright © 2026 Marc Rousavy @ Margelo
+# Copyright © Marc Rousavy @ Margelo
 #
 
 # This is a Ruby script that adds all files generated by Nitrogen
@@ -52,9 +52,11 @@ def add_nitrogen_files(spec)
   spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
     # Use C++ 20
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-    # Enables C++ <-> Swift interop (by default it's only C)
+    # Enables C++ <-> Swift interop (by default it's only ObjC)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",
+    # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+    "SWIFT_INSTALL_OBJC_HEADER" => "NO",
   })
 end

package/nitrogen/generated/ios/AcousticConnectRN-Swift-Cxx-Bridge.cpp

@@ -2,7 +2,7 @@
 /// AcousticConnectRN-Swift-Cxx-Bridge.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #include "AcousticConnectRN-Swift-Cxx-Bridge.hpp"
@@ -10,21 +10,22 @@
 // Include C++ implementation defined types
 #include "AcousticConnectRN-Swift-Cxx-Umbrella.hpp"
 #include "HybridAcousticConnectRNSpecSwift.hpp"
+#include <NitroModules/NitroDefines.hpp>
 
 namespace margelo::nitro::acousticconnectrn::bridge::swift {
 
-  // pragma MARK: std::shared_ptr<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpec>
-  std::shared_ptr<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpec> create_std__shared_ptr_margelo__nitro__acousticconnectrn__HybridAcousticConnectRNSpec_(void* _Nonnull swiftUnsafePointer) {
+  // pragma MARK: std::shared_ptr<HybridAcousticConnectRNSpec>
+  std::shared_ptr<HybridAcousticConnectRNSpec> create_std__shared_ptr_HybridAcousticConnectRNSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     AcousticConnectRN::HybridAcousticConnectRNSpec_cxx swiftPart = AcousticConnectRN::HybridAcousticConnectRNSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__acousticconnectrn__HybridAcousticConnectRNSpec_(std__shared_ptr_margelo__nitro__acousticconnectrn__HybridAcousticConnectRNSpec_ cppType) {
+  void* NON_NULL get_std__shared_ptr_HybridAcousticConnectRNSpec_(std__shared_ptr_HybridAcousticConnectRNSpec_ cppType) {
     std::shared_ptr<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
+    #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
       throw std::runtime_error("Class \"HybridAcousticConnectRNSpec\" is not implemented in Swift!");
     }
-  #endif
+    #endif
     AcousticConnectRN::HybridAcousticConnectRNSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }

package/nitrogen/generated/ios/AcousticConnectRN-Swift-Cxx-Bridge.hpp

@@ -2,7 +2,7 @@
 /// AcousticConnectRN-Swift-Cxx-Bridge.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -17,6 +17,7 @@ namespace AcousticConnectRN { class HybridAcousticConnectRNSpec_cxx; }
 
 // Include C++ defined types
 #include "HybridAcousticConnectRNSpec.hpp"
+#include <NitroModules/Null.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <memory>
@@ -31,61 +32,96 @@ namespace AcousticConnectRN { class HybridAcousticConnectRNSpec_cxx; }
  */
 namespace margelo::nitro::acousticconnectrn::bridge::swift {
 
-  // pragma MARK: std::variant<std::string, double, bool>
+  // pragma MARK: std::variant<bool, std::string, double>
   /**
-   * Wrapper struct for `std::variant<std::string, double, bool>`.
+   * Wrapper struct for `std::variant<bool, std::string, double>`.
    * 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__bool_ {
-    std::variant<std::string, double, bool> variant;
-    std__variant_std__string__double__bool_(std::variant<std::string, double, bool> variant): variant(variant) { }
-    operator std::variant<std::string, double, bool>() const {
+  struct std__variant_bool__std__string__double_ final {
+    std::variant<bool, std::string, double> variant;
+    std__variant_bool__std__string__double_(std::variant<bool, std::string, double> variant): variant(variant) { }
+    operator std::variant<bool, std::string, double>() const noexcept {
       return variant;
     }
-    inline size_t index() const {
+    inline size_t index() const noexcept {
       return variant.index();
     }
-    inline std::string get_0() const {
+    inline bool get_0() const noexcept {
       return std::get<0>(variant);
     }
-    inline double get_1() const {
+    inline std::string get_1() const noexcept {
       return std::get<1>(variant);
     }
-    inline bool get_2() const {
+    inline double get_2() const noexcept {
       return std::get<2>(variant);
     }
   };
-  inline std__variant_std__string__double__bool_ create_std__variant_std__string__double__bool_(const std::string& value) {
-    return std__variant_std__string__double__bool_(value);
+  inline std__variant_bool__std__string__double_ create_std__variant_bool__std__string__double_(bool value) noexcept {
+    return std__variant_bool__std__string__double_(value);
   }
-  inline std__variant_std__string__double__bool_ create_std__variant_std__string__double__bool_(double value) {
-    return std__variant_std__string__double__bool_(value);
+  inline std__variant_bool__std__string__double_ create_std__variant_bool__std__string__double_(const std::string& value) noexcept {
+    return std__variant_bool__std__string__double_(value);
   }
-  inline std__variant_std__string__double__bool_ create_std__variant_std__string__double__bool_(bool value) {
-    return std__variant_std__string__double__bool_(value);
+  inline std__variant_bool__std__string__double_ create_std__variant_bool__std__string__double_(double value) noexcept {
+    return std__variant_bool__std__string__double_(value);
   }
   
-  // pragma MARK: std::optional<std::string>
+  // pragma MARK: std::variant<nitro::NullType, std::string>
   /**
-   * Specialized version of `std::optional<std::string>`.
+   * Wrapper struct for `std::variant<nitro::NullType, 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.
    */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) {
-    return std::optional<std::string>(value);
+  struct std__variant_nitro__NullType__std__string_ final {
+    std::variant<nitro::NullType, std::string> variant;
+    std__variant_nitro__NullType__std__string_(std::variant<nitro::NullType, std::string> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::string>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline std::string get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(const std::string& value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
   }
   
-  // pragma MARK: std::unordered_map<std::string, std::variant<std::string, double, bool>>
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::string>>
   /**
-   * Specialized version of `std::unordered_map<std::string, std::variant<std::string, double, bool>>`.
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::string>>`.
    */
-  using std__unordered_map_std__string__std__variant_std__string__double__bool__ = std::unordered_map<std::string, std::variant<std::string, double, bool>>;
-  inline std::unordered_map<std::string, std::variant<std::string, double, bool>> create_std__unordered_map_std__string__std__variant_std__string__double__bool__(size_t size) {
-    std::unordered_map<std::string, std::variant<std::string, double, bool>> map;
+  using std__optional_std__variant_nitro__NullType__std__string__ = std::optional<std::variant<nitro::NullType, std::string>>;
+  inline std::optional<std::variant<nitro::NullType, std::string>> create_std__optional_std__variant_nitro__NullType__std__string__(const std::variant<nitro::NullType, std::string>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::string>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__string__(const std::optional<std::variant<nitro::NullType, std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, std::string> get_std__optional_std__variant_nitro__NullType__std__string__(const std::optional<std::variant<nitro::NullType, std::string>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::unordered_map<std::string, std::variant<bool, std::string, double>>
+  /**
+   * Specialized version of `std::unordered_map<std::string, std::variant<bool, std::string, double>>`.
+   */
+  using std__unordered_map_std__string__std__variant_bool__std__string__double__ = std::unordered_map<std::string, std::variant<bool, std::string, double>>;
+  inline std::unordered_map<std::string, std::variant<bool, std::string, double>> create_std__unordered_map_std__string__std__variant_bool__std__string__double__(size_t size) noexcept {
+    std::unordered_map<std::string, std::variant<bool, std::string, double>> map;
     map.reserve(size);
     return map;
   }
-  inline std::vector<std::string> get_std__unordered_map_std__string__std__variant_std__string__double__bool___keys(const std__unordered_map_std__string__std__variant_std__string__double__bool__& map) {
+  inline std::vector<std::string> get_std__unordered_map_std__string__std__variant_bool__std__string__double___keys(const std__unordered_map_std__string__std__variant_bool__std__string__double__& map) noexcept {
     std::vector<std::string> keys;
     keys.reserve(map.size());
     for (const auto& entry : map) {
@@ -93,46 +129,49 @@ namespace margelo::nitro::acousticconnectrn::bridge::swift {
     }
     return keys;
   }
-  inline void emplace_std__unordered_map_std__string__std__variant_std__string__double__bool__(std__unordered_map_std__string__std__variant_std__string__double__bool__& map, const std::string& key, const std::variant<std::string, double, bool>& value) {
+  inline std::variant<bool, std::string, double> get_std__unordered_map_std__string__std__variant_bool__std__string__double___value(const std__unordered_map_std__string__std__variant_bool__std__string__double__& map, const std::string& key) noexcept {
+    return map.find(key)->second;
+  }
+  inline void emplace_std__unordered_map_std__string__std__variant_bool__std__string__double__(std__unordered_map_std__string__std__variant_bool__std__string__double__& map, const std::string& key, const std::variant<bool, std::string, double>& value) noexcept {
     map.emplace(key, value);
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpec>
+  // pragma MARK: std::shared_ptr<HybridAcousticConnectRNSpec>
   /**
-   * Specialized version of `std::shared_ptr<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpec>`.
+   * Specialized version of `std::shared_ptr<HybridAcousticConnectRNSpec>`.
    */
-  using std__shared_ptr_margelo__nitro__acousticconnectrn__HybridAcousticConnectRNSpec_ = std::shared_ptr<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpec>;
-  std::shared_ptr<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpec> create_std__shared_ptr_margelo__nitro__acousticconnectrn__HybridAcousticConnectRNSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__acousticconnectrn__HybridAcousticConnectRNSpec_(std__shared_ptr_margelo__nitro__acousticconnectrn__HybridAcousticConnectRNSpec_ cppType);
+  using std__shared_ptr_HybridAcousticConnectRNSpec_ = std::shared_ptr<HybridAcousticConnectRNSpec>;
+  std::shared_ptr<HybridAcousticConnectRNSpec> create_std__shared_ptr_HybridAcousticConnectRNSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridAcousticConnectRNSpec_(std__shared_ptr_HybridAcousticConnectRNSpec_ cppType);
   
-  // pragma MARK: std::weak_ptr<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpec>
-  using std__weak_ptr_margelo__nitro__acousticconnectrn__HybridAcousticConnectRNSpec_ = std::weak_ptr<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpec>;
-  inline std__weak_ptr_margelo__nitro__acousticconnectrn__HybridAcousticConnectRNSpec_ weakify_std__shared_ptr_margelo__nitro__acousticconnectrn__HybridAcousticConnectRNSpec_(const std::shared_ptr<margelo::nitro::acousticconnectrn::HybridAcousticConnectRNSpec>& strong) { return strong; }
+  // pragma MARK: std::weak_ptr<HybridAcousticConnectRNSpec>
+  using std__weak_ptr_HybridAcousticConnectRNSpec_ = std::weak_ptr<HybridAcousticConnectRNSpec>;
+  inline std__weak_ptr_HybridAcousticConnectRNSpec_ weakify_std__shared_ptr_HybridAcousticConnectRNSpec_(const std::shared_ptr<HybridAcousticConnectRNSpec>& strong) noexcept { return strong; }
   
   // pragma MARK: Result<bool>
   using Result_bool_ = Result<bool>;
-  inline Result_bool_ create_Result_bool_(bool value) {
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
     return Result<bool>::withValue(std::move(value));
   }
-  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) {
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
     return Result<bool>::withError(error);
   }
   
-  // pragma MARK: Result<std::optional<std::string>>
-  using Result_std__optional_std__string__ = Result<std::optional<std::string>>;
-  inline Result_std__optional_std__string__ create_Result_std__optional_std__string__(const std::optional<std::string>& value) {
-    return Result<std::optional<std::string>>::withValue(value);
+  // pragma MARK: Result<std::optional<std::variant<nitro::NullType, std::string>>>
+  using Result_std__optional_std__variant_nitro__NullType__std__string___ = Result<std::optional<std::variant<nitro::NullType, std::string>>>;
+  inline Result_std__optional_std__variant_nitro__NullType__std__string___ create_Result_std__optional_std__variant_nitro__NullType__std__string___(const std::optional<std::variant<nitro::NullType, std::string>>& value) noexcept {
+    return Result<std::optional<std::variant<nitro::NullType, std::string>>>::withValue(value);
   }
-  inline Result_std__optional_std__string__ create_Result_std__optional_std__string__(const std::exception_ptr& error) {
-    return Result<std::optional<std::string>>::withError(error);
+  inline Result_std__optional_std__variant_nitro__NullType__std__string___ create_Result_std__optional_std__variant_nitro__NullType__std__string___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::variant<nitro::NullType, std::string>>>::withError(error);
   }
   
   // pragma MARK: Result<double>
   using Result_double_ = Result<double>;
-  inline Result_double_ create_Result_double_(double value) {
+  inline Result_double_ create_Result_double_(double value) noexcept {
     return Result<double>::withValue(std::move(value));
   }
-  inline Result_double_ create_Result_double_(const std::exception_ptr& error) {
+  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
     return Result<double>::withError(error);
   }