securiti-consent-sdk 1.141.0-1rc → 1.141.0-20rc

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

@@ -44,6 +44,7 @@ namespace NitroSecuritiConsentSdk { class HybridConsentSDKSpec_cxx; }
 #include "PurposeConsent.hpp"
 #include "SDK.hpp"
 #include "SettingsPrompt.hpp"
+#include <NitroModules/Null.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -53,6 +54,7 @@ namespace NitroSecuritiConsentSdk { class HybridConsentSDKSpec_cxx; }
 #include <optional>
 #include <string>
 #include <unordered_map>
+#include <variant>
 #include <vector>
 
 /**
@@ -66,9 +68,15 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::optional<std::string>`.
    */
   using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) {
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
     return std::optional<std::string>(value);
   }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::function<void(bool /* isReady */)>
   /**
@@ -80,15 +88,15 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    */
   class Func_void_bool_Wrapper final {
   public:
-    explicit Func_void_bool_Wrapper(std::function<void(bool /* isReady */)>&& func): _function(std::make_shared<std::function<void(bool /* isReady */)>>(std::move(func))) {}
-    inline void call(bool isReady) const {
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* isReady */)>&& func): _function(std::make_unique<std::function<void(bool /* isReady */)>>(std::move(func))) {}
+    inline void call(bool isReady) const noexcept {
       _function->operator()(isReady);
     }
   private:
-    std::shared_ptr<std::function<void(bool /* isReady */)>> _function;
-  };
-  Func_void_bool create_Func_void_bool(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) {
+    std::unique_ptr<std::function<void(bool /* isReady */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
     return Func_void_bool_Wrapper(std::move(value));
   }
   
@@ -97,10 +105,10 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::shared_ptr<Promise<std::string>>`.
    */
   using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
-  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() {
+  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() noexcept {
     return Promise<std::string>::create();
   }
-  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) {
+  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) noexcept {
     return PromiseHolder<std::string>(std::move(promise));
   }
   
@@ -114,15 +122,15 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    */
   class Func_void_std__string_Wrapper final {
   public:
-    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
-    inline void call(std::string result) const {
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
+    inline void call(std::string result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::string& /* result */)>> _function;
-  };
-  Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) {
+    std::unique_ptr<std::function<void(const std::string& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
     return Func_void_std__string_Wrapper(std::move(value));
   }
   
@@ -136,15 +144,15 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    */
   class Func_void_std__exception_ptr_Wrapper final {
   public:
-    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_shared<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
-    inline void call(std::exception_ptr error) const {
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const noexcept {
       _function->operator()(error);
     }
   private:
-    std::shared_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
-  };
-  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) {
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
@@ -153,25 +161,37 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::optional<double>`.
    */
   using std__optional_double_ = std::optional<double>;
-  inline std::optional<double> create_std__optional_double_(const double& value) {
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
     return std::optional<double>(value);
   }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::optional<bool>
   /**
    * Specialized version of `std::optional<bool>`.
    */
   using std__optional_bool_ = std::optional<bool>;
-  inline std::optional<bool> create_std__optional_bool_(const bool& value) {
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
     return std::optional<bool>(value);
   }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::vector<AppPermission>
   /**
    * Specialized version of `std::vector<AppPermission>`.
    */
   using std__vector_AppPermission_ = std::vector<AppPermission>;
-  inline std::vector<AppPermission> create_std__vector_AppPermission_(size_t size) {
+  inline std::vector<AppPermission> create_std__vector_AppPermission_(size_t size) noexcept {
     std::vector<AppPermission> vector;
     vector.reserve(size);
     return vector;
@@ -182,10 +202,10 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::shared_ptr<Promise<std::vector<AppPermission>>>`.
    */
   using std__shared_ptr_Promise_std__vector_AppPermission___ = std::shared_ptr<Promise<std::vector<AppPermission>>>;
-  inline std::shared_ptr<Promise<std::vector<AppPermission>>> create_std__shared_ptr_Promise_std__vector_AppPermission___() {
+  inline std::shared_ptr<Promise<std::vector<AppPermission>>> create_std__shared_ptr_Promise_std__vector_AppPermission___() noexcept {
     return Promise<std::vector<AppPermission>>::create();
   }
-  inline PromiseHolder<std::vector<AppPermission>> wrap_std__shared_ptr_Promise_std__vector_AppPermission___(std::shared_ptr<Promise<std::vector<AppPermission>>> promise) {
+  inline PromiseHolder<std::vector<AppPermission>> wrap_std__shared_ptr_Promise_std__vector_AppPermission___(std::shared_ptr<Promise<std::vector<AppPermission>>> promise) noexcept {
     return PromiseHolder<std::vector<AppPermission>>(std::move(promise));
   }
   
@@ -199,15 +219,15 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    */
   class Func_void_std__vector_AppPermission__Wrapper final {
   public:
-    explicit Func_void_std__vector_AppPermission__Wrapper(std::function<void(const std::vector<AppPermission>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<AppPermission>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<AppPermission> result) const {
+    explicit Func_void_std__vector_AppPermission__Wrapper(std::function<void(const std::vector<AppPermission>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<AppPermission>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<AppPermission> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<AppPermission>& /* result */)>> _function;
-  };
-  Func_void_std__vector_AppPermission_ create_Func_void_std__vector_AppPermission_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_AppPermission__Wrapper wrap_Func_void_std__vector_AppPermission_(Func_void_std__vector_AppPermission_ value) {
+    std::unique_ptr<std::function<void(const std::vector<AppPermission>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_AppPermission_ create_Func_void_std__vector_AppPermission_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_AppPermission__Wrapper wrap_Func_void_std__vector_AppPermission_(Func_void_std__vector_AppPermission_ value) noexcept {
     return Func_void_std__vector_AppPermission__Wrapper(std::move(value));
   }
   
@@ -216,7 +236,7 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::vector<std::string>`.
    */
   using std__vector_std__string_ = std::vector<std::string>;
-  inline std::vector<std::string> create_std__vector_std__string_(size_t size) {
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
     std::vector<std::string> vector;
     vector.reserve(size);
     return vector;
@@ -227,16 +247,22 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::optional<std::vector<std::string>>`.
    */
   using std__optional_std__vector_std__string__ = std::optional<std::vector<std::string>>;
-  inline std::optional<std::vector<std::string>> create_std__optional_std__vector_std__string__(const std::vector<std::string>& value) {
+  inline std::optional<std::vector<std::string>> create_std__optional_std__vector_std__string__(const std::vector<std::string>& value) noexcept {
     return std::optional<std::vector<std::string>>(value);
   }
+  inline bool has_value_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<std::string> get_std__optional_std__vector_std__string__(const std::optional<std::vector<std::string>>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::vector<SDK>
   /**
    * Specialized version of `std::vector<SDK>`.
    */
   using std__vector_SDK_ = std::vector<SDK>;
-  inline std::vector<SDK> create_std__vector_SDK_(size_t size) {
+  inline std::vector<SDK> create_std__vector_SDK_(size_t size) noexcept {
     std::vector<SDK> vector;
     vector.reserve(size);
     return vector;
@@ -247,16 +273,22 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::optional<std::vector<SDK>>`.
    */
   using std__optional_std__vector_SDK__ = std::optional<std::vector<SDK>>;
-  inline std::optional<std::vector<SDK>> create_std__optional_std__vector_SDK__(const std::vector<SDK>& value) {
+  inline std::optional<std::vector<SDK>> create_std__optional_std__vector_SDK__(const std::vector<SDK>& value) noexcept {
     return std::optional<std::vector<SDK>>(value);
   }
+  inline bool has_value_std__optional_std__vector_SDK__(const std::optional<std::vector<SDK>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<SDK> get_std__optional_std__vector_SDK__(const std::optional<std::vector<SDK>>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::vector<Purpose>
   /**
    * Specialized version of `std::vector<Purpose>`.
    */
   using std__vector_Purpose_ = std::vector<Purpose>;
-  inline std::vector<Purpose> create_std__vector_Purpose_(size_t size) {
+  inline std::vector<Purpose> create_std__vector_Purpose_(size_t size) noexcept {
     std::vector<Purpose> vector;
     vector.reserve(size);
     return vector;
@@ -267,10 +299,10 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::shared_ptr<Promise<std::vector<Purpose>>>`.
    */
   using std__shared_ptr_Promise_std__vector_Purpose___ = std::shared_ptr<Promise<std::vector<Purpose>>>;
-  inline std::shared_ptr<Promise<std::vector<Purpose>>> create_std__shared_ptr_Promise_std__vector_Purpose___() {
+  inline std::shared_ptr<Promise<std::vector<Purpose>>> create_std__shared_ptr_Promise_std__vector_Purpose___() noexcept {
     return Promise<std::vector<Purpose>>::create();
   }
-  inline PromiseHolder<std::vector<Purpose>> wrap_std__shared_ptr_Promise_std__vector_Purpose___(std::shared_ptr<Promise<std::vector<Purpose>>> promise) {
+  inline PromiseHolder<std::vector<Purpose>> wrap_std__shared_ptr_Promise_std__vector_Purpose___(std::shared_ptr<Promise<std::vector<Purpose>>> promise) noexcept {
     return PromiseHolder<std::vector<Purpose>>(std::move(promise));
   }
   
@@ -284,15 +316,15 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    */
   class Func_void_std__vector_Purpose__Wrapper final {
   public:
-    explicit Func_void_std__vector_Purpose__Wrapper(std::function<void(const std::vector<Purpose>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<Purpose>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<Purpose> result) const {
+    explicit Func_void_std__vector_Purpose__Wrapper(std::function<void(const std::vector<Purpose>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<Purpose>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<Purpose> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<Purpose>& /* result */)>> _function;
-  };
-  Func_void_std__vector_Purpose_ create_Func_void_std__vector_Purpose_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_Purpose__Wrapper wrap_Func_void_std__vector_Purpose_(Func_void_std__vector_Purpose_ value) {
+    std::unique_ptr<std::function<void(const std::vector<Purpose>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_Purpose_ create_Func_void_std__vector_Purpose_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_Purpose__Wrapper wrap_Func_void_std__vector_Purpose_(Func_void_std__vector_Purpose_ value) noexcept {
     return Func_void_std__vector_Purpose__Wrapper(std::move(value));
   }
   
@@ -301,10 +333,10 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::shared_ptr<Promise<std::vector<SDK>>>`.
    */
   using std__shared_ptr_Promise_std__vector_SDK___ = std::shared_ptr<Promise<std::vector<SDK>>>;
-  inline std::shared_ptr<Promise<std::vector<SDK>>> create_std__shared_ptr_Promise_std__vector_SDK___() {
+  inline std::shared_ptr<Promise<std::vector<SDK>>> create_std__shared_ptr_Promise_std__vector_SDK___() noexcept {
     return Promise<std::vector<SDK>>::create();
   }
-  inline PromiseHolder<std::vector<SDK>> wrap_std__shared_ptr_Promise_std__vector_SDK___(std::shared_ptr<Promise<std::vector<SDK>>> promise) {
+  inline PromiseHolder<std::vector<SDK>> wrap_std__shared_ptr_Promise_std__vector_SDK___(std::shared_ptr<Promise<std::vector<SDK>>> promise) noexcept {
     return PromiseHolder<std::vector<SDK>>(std::move(promise));
   }
   
@@ -318,38 +350,29 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    */
   class Func_void_std__vector_SDK__Wrapper final {
   public:
-    explicit Func_void_std__vector_SDK__Wrapper(std::function<void(const std::vector<SDK>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<SDK>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<SDK> result) const {
+    explicit Func_void_std__vector_SDK__Wrapper(std::function<void(const std::vector<SDK>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<SDK>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<SDK> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::vector<SDK>& /* result */)>> _function;
-  };
-  Func_void_std__vector_SDK_ create_Func_void_std__vector_SDK_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_SDK__Wrapper wrap_Func_void_std__vector_SDK_(Func_void_std__vector_SDK_ value) {
+    std::unique_ptr<std::function<void(const std::vector<SDK>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_SDK_ create_Func_void_std__vector_SDK_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_SDK__Wrapper wrap_Func_void_std__vector_SDK_(Func_void_std__vector_SDK_ value) noexcept {
     return Func_void_std__vector_SDK__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<CustomColors>
-  /**
-   * Specialized version of `std::optional<CustomColors>`.
-   */
-  using std__optional_CustomColors_ = std::optional<CustomColors>;
-  inline std::optional<CustomColors> create_std__optional_CustomColors_(const CustomColors& value) {
-    return std::optional<CustomColors>(value);
-  }
-  
   // pragma MARK: std::unordered_map<std::string, std::string>
   /**
    * Specialized version of `std::unordered_map<std::string, std::string>`.
    */
   using std__unordered_map_std__string__std__string_ = std::unordered_map<std::string, std::string>;
-  inline std::unordered_map<std::string, std::string> create_std__unordered_map_std__string__std__string_(size_t size) {
+  inline std::unordered_map<std::string, std::string> create_std__unordered_map_std__string__std__string_(size_t size) noexcept {
     std::unordered_map<std::string, std::string> map;
     map.reserve(size);
     return map;
   }
-  inline std::vector<std::string> get_std__unordered_map_std__string__std__string__keys(const std__unordered_map_std__string__std__string_& map) {
+  inline std::vector<std::string> get_std__unordered_map_std__string__std__string__keys(const std__unordered_map_std__string__std__string_& map) noexcept {
     std::vector<std::string> keys;
     keys.reserve(map.size());
     for (const auto& entry : map) {
@@ -357,112 +380,230 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
     }
     return keys;
   }
-  inline void emplace_std__unordered_map_std__string__std__string_(std__unordered_map_std__string__std__string_& map, const std::string& key, const std::string& value) {
+  inline std::string get_std__unordered_map_std__string__std__string__value(const std__unordered_map_std__string__std__string_& map, const std::string& key) noexcept {
+    return map.find(key)->second;
+  }
+  inline void emplace_std__unordered_map_std__string__std__string_(std__unordered_map_std__string__std__string_& map, const std::string& key, const std::string& value) noexcept {
     map.emplace(key, value);
   }
   
+  // pragma MARK: std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>`.
+   */
+  using std__shared_ptr_Promise_std__unordered_map_std__string__std__string___ = std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>;
+  inline std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>> create_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___() noexcept {
+    return Promise<std::unordered_map<std::string, std::string>>::create();
+  }
+  inline PromiseHolder<std::unordered_map<std::string, std::string>> wrap_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___(std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>> promise) noexcept {
+    return PromiseHolder<std::unordered_map<std::string, std::string>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::unordered_map<std::string, std::string>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::unordered_map<std::string, std::string>&)>`.
+   */
+  using Func_void_std__unordered_map_std__string__std__string_ = std::function<void(const std::unordered_map<std::string, std::string>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::unordered_map<std::string, std::string>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__unordered_map_std__string__std__string__Wrapper final {
+  public:
+    explicit Func_void_std__unordered_map_std__string__std__string__Wrapper(std::function<void(const std::unordered_map<std::string, std::string>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::unordered_map<std::string, std::string>& /* result */)>>(std::move(func))) {}
+    inline void call(std::unordered_map<std::string, std::string> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::unordered_map<std::string, std::string>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__unordered_map_std__string__std__string_ create_Func_void_std__unordered_map_std__string__std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__unordered_map_std__string__std__string__Wrapper wrap_Func_void_std__unordered_map_std__string__std__string_(Func_void_std__unordered_map_std__string__std__string_ value) noexcept {
+    return Func_void_std__unordered_map_std__string__std__string__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<CustomColors>
+  /**
+   * Specialized version of `std::optional<CustomColors>`.
+   */
+  using std__optional_CustomColors_ = std::optional<CustomColors>;
+  inline std::optional<CustomColors> create_std__optional_CustomColors_(const CustomColors& value) noexcept {
+    return std::optional<CustomColors>(value);
+  }
+  inline bool has_value_std__optional_CustomColors_(const std::optional<CustomColors>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline CustomColors get_std__optional_CustomColors_(const std::optional<CustomColors>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::optional<std::unordered_map<std::string, std::string>>
   /**
    * Specialized version of `std::optional<std::unordered_map<std::string, std::string>>`.
    */
   using std__optional_std__unordered_map_std__string__std__string__ = std::optional<std::unordered_map<std::string, std::string>>;
-  inline std::optional<std::unordered_map<std::string, std::string>> create_std__optional_std__unordered_map_std__string__std__string__(const std::unordered_map<std::string, std::string>& value) {
+  inline std::optional<std::unordered_map<std::string, std::string>> create_std__optional_std__unordered_map_std__string__std__string__(const std::unordered_map<std::string, std::string>& value) noexcept {
     return std::optional<std::unordered_map<std::string, std::string>>(value);
   }
+  inline bool has_value_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::unordered_map<std::string, std::string> get_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
+    return *optional;
+  }
   
-  // pragma MARK: std::optional<BannerConfig>
+  // pragma MARK: std::variant<nitro::NullType, BannerConfig>
   /**
-   * Specialized version of `std::optional<BannerConfig>`.
+   * Wrapper struct for `std::variant<nitro::NullType, BannerConfig>`.
+   * 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_BannerConfig_ = std::optional<BannerConfig>;
-  inline std::optional<BannerConfig> create_std__optional_BannerConfig_(const BannerConfig& value) {
-    return std::optional<BannerConfig>(value);
+  struct std__variant_nitro__NullType__BannerConfig_ {
+    std::variant<nitro::NullType, BannerConfig> variant;
+    std__variant_nitro__NullType__BannerConfig_(std::variant<nitro::NullType, BannerConfig> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, BannerConfig>() 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 BannerConfig get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__BannerConfig_ create_std__variant_nitro__NullType__BannerConfig_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__BannerConfig_(value);
+  }
+  inline std__variant_nitro__NullType__BannerConfig_ create_std__variant_nitro__NullType__BannerConfig_(const BannerConfig& value) noexcept {
+    return std__variant_nitro__NullType__BannerConfig_(value);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::optional<BannerConfig>>>
+  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, BannerConfig>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::optional<BannerConfig>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, BannerConfig>>>`.
    */
-  using std__shared_ptr_Promise_std__optional_BannerConfig___ = std::shared_ptr<Promise<std::optional<BannerConfig>>>;
-  inline std::shared_ptr<Promise<std::optional<BannerConfig>>> create_std__shared_ptr_Promise_std__optional_BannerConfig___() {
-    return Promise<std::optional<BannerConfig>>::create();
+  using std__shared_ptr_Promise_std__variant_nitro__NullType__BannerConfig___ = std::shared_ptr<Promise<std::variant<nitro::NullType, BannerConfig>>>;
+  inline std::shared_ptr<Promise<std::variant<nitro::NullType, BannerConfig>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__BannerConfig___() noexcept {
+    return Promise<std::variant<nitro::NullType, BannerConfig>>::create();
   }
-  inline PromiseHolder<std::optional<BannerConfig>> wrap_std__shared_ptr_Promise_std__optional_BannerConfig___(std::shared_ptr<Promise<std::optional<BannerConfig>>> promise) {
-    return PromiseHolder<std::optional<BannerConfig>>(std::move(promise));
+  inline PromiseHolder<std::variant<nitro::NullType, BannerConfig>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__BannerConfig___(std::shared_ptr<Promise<std::variant<nitro::NullType, BannerConfig>>> promise) noexcept {
+    return PromiseHolder<std::variant<nitro::NullType, BannerConfig>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::optional<BannerConfig>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, BannerConfig>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::optional<BannerConfig>&)>`.
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, BannerConfig>&)>`.
    */
-  using Func_void_std__optional_BannerConfig_ = std::function<void(const std::optional<BannerConfig>& /* result */)>;
+  using Func_void_std__variant_nitro__NullType__BannerConfig_ = std::function<void(const std::variant<nitro::NullType, BannerConfig>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::optional<BannerConfig>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, BannerConfig>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__optional_BannerConfig__Wrapper final {
+  class Func_void_std__variant_nitro__NullType__BannerConfig__Wrapper final {
   public:
-    explicit Func_void_std__optional_BannerConfig__Wrapper(std::function<void(const std::optional<BannerConfig>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::optional<BannerConfig>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<BannerConfig> result) const {
+    explicit Func_void_std__variant_nitro__NullType__BannerConfig__Wrapper(std::function<void(const std::variant<nitro::NullType, BannerConfig>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, BannerConfig>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<nitro::NullType, BannerConfig> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::optional<BannerConfig>& /* result */)>> _function;
-  };
-  Func_void_std__optional_BannerConfig_ create_Func_void_std__optional_BannerConfig_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__optional_BannerConfig__Wrapper wrap_Func_void_std__optional_BannerConfig_(Func_void_std__optional_BannerConfig_ value) {
-    return Func_void_std__optional_BannerConfig__Wrapper(std::move(value));
+    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, BannerConfig>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__variant_nitro__NullType__BannerConfig_ create_Func_void_std__variant_nitro__NullType__BannerConfig_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_nitro__NullType__BannerConfig__Wrapper wrap_Func_void_std__variant_nitro__NullType__BannerConfig_(Func_void_std__variant_nitro__NullType__BannerConfig_ value) noexcept {
+    return Func_void_std__variant_nitro__NullType__BannerConfig__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<CmpSDKOptions>
+  // pragma MARK: std::variant<nitro::NullType, CmpSDKOptions>
   /**
-   * Specialized version of `std::optional<CmpSDKOptions>`.
+   * Wrapper struct for `std::variant<nitro::NullType, CmpSDKOptions>`.
+   * 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_CmpSDKOptions_ = std::optional<CmpSDKOptions>;
-  inline std::optional<CmpSDKOptions> create_std__optional_CmpSDKOptions_(const CmpSDKOptions& value) {
-    return std::optional<CmpSDKOptions>(value);
+  struct std__variant_nitro__NullType__CmpSDKOptions_ {
+    std::variant<nitro::NullType, CmpSDKOptions> variant;
+    std__variant_nitro__NullType__CmpSDKOptions_(std::variant<nitro::NullType, CmpSDKOptions> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, CmpSDKOptions>() 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 CmpSDKOptions get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__CmpSDKOptions_ create_std__variant_nitro__NullType__CmpSDKOptions_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__CmpSDKOptions_(value);
+  }
+  inline std__variant_nitro__NullType__CmpSDKOptions_ create_std__variant_nitro__NullType__CmpSDKOptions_(const CmpSDKOptions& value) noexcept {
+    return std__variant_nitro__NullType__CmpSDKOptions_(value);
   }
   
-  // pragma MARK: std::optional<SettingsPrompt>
+  // pragma MARK: std::variant<nitro::NullType, SettingsPrompt>
   /**
-   * Specialized version of `std::optional<SettingsPrompt>`.
+   * Wrapper struct for `std::variant<nitro::NullType, SettingsPrompt>`.
+   * 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_SettingsPrompt_ = std::optional<SettingsPrompt>;
-  inline std::optional<SettingsPrompt> create_std__optional_SettingsPrompt_(const SettingsPrompt& value) {
-    return std::optional<SettingsPrompt>(value);
+  struct std__variant_nitro__NullType__SettingsPrompt_ {
+    std::variant<nitro::NullType, SettingsPrompt> variant;
+    std__variant_nitro__NullType__SettingsPrompt_(std::variant<nitro::NullType, SettingsPrompt> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, SettingsPrompt>() 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 SettingsPrompt get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__SettingsPrompt_ create_std__variant_nitro__NullType__SettingsPrompt_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__SettingsPrompt_(value);
+  }
+  inline std__variant_nitro__NullType__SettingsPrompt_ create_std__variant_nitro__NullType__SettingsPrompt_(const SettingsPrompt& value) noexcept {
+    return std__variant_nitro__NullType__SettingsPrompt_(value);
   }
   
-  // pragma MARK: std::shared_ptr<Promise<std::optional<SettingsPrompt>>>
+  // pragma MARK: std::shared_ptr<Promise<std::variant<nitro::NullType, SettingsPrompt>>>
   /**
-   * Specialized version of `std::shared_ptr<Promise<std::optional<SettingsPrompt>>>`.
+   * Specialized version of `std::shared_ptr<Promise<std::variant<nitro::NullType, SettingsPrompt>>>`.
    */
-  using std__shared_ptr_Promise_std__optional_SettingsPrompt___ = std::shared_ptr<Promise<std::optional<SettingsPrompt>>>;
-  inline std::shared_ptr<Promise<std::optional<SettingsPrompt>>> create_std__shared_ptr_Promise_std__optional_SettingsPrompt___() {
-    return Promise<std::optional<SettingsPrompt>>::create();
+  using std__shared_ptr_Promise_std__variant_nitro__NullType__SettingsPrompt___ = std::shared_ptr<Promise<std::variant<nitro::NullType, SettingsPrompt>>>;
+  inline std::shared_ptr<Promise<std::variant<nitro::NullType, SettingsPrompt>>> create_std__shared_ptr_Promise_std__variant_nitro__NullType__SettingsPrompt___() noexcept {
+    return Promise<std::variant<nitro::NullType, SettingsPrompt>>::create();
   }
-  inline PromiseHolder<std::optional<SettingsPrompt>> wrap_std__shared_ptr_Promise_std__optional_SettingsPrompt___(std::shared_ptr<Promise<std::optional<SettingsPrompt>>> promise) {
-    return PromiseHolder<std::optional<SettingsPrompt>>(std::move(promise));
+  inline PromiseHolder<std::variant<nitro::NullType, SettingsPrompt>> wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__SettingsPrompt___(std::shared_ptr<Promise<std::variant<nitro::NullType, SettingsPrompt>>> promise) noexcept {
+    return PromiseHolder<std::variant<nitro::NullType, SettingsPrompt>>(std::move(promise));
   }
   
-  // pragma MARK: std::function<void(const std::optional<SettingsPrompt>& /* result */)>
+  // pragma MARK: std::function<void(const std::variant<nitro::NullType, SettingsPrompt>& /* result */)>
   /**
-   * Specialized version of `std::function<void(const std::optional<SettingsPrompt>&)>`.
+   * Specialized version of `std::function<void(const std::variant<nitro::NullType, SettingsPrompt>&)>`.
    */
-  using Func_void_std__optional_SettingsPrompt_ = std::function<void(const std::optional<SettingsPrompt>& /* result */)>;
+  using Func_void_std__variant_nitro__NullType__SettingsPrompt_ = std::function<void(const std::variant<nitro::NullType, SettingsPrompt>& /* result */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::optional<SettingsPrompt>& / * result * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(const std::variant<nitro::NullType, SettingsPrompt>& / * result * /)>`, this can be used from Swift.
    */
-  class Func_void_std__optional_SettingsPrompt__Wrapper final {
+  class Func_void_std__variant_nitro__NullType__SettingsPrompt__Wrapper final {
   public:
-    explicit Func_void_std__optional_SettingsPrompt__Wrapper(std::function<void(const std::optional<SettingsPrompt>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::optional<SettingsPrompt>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<SettingsPrompt> result) const {
+    explicit Func_void_std__variant_nitro__NullType__SettingsPrompt__Wrapper(std::function<void(const std::variant<nitro::NullType, SettingsPrompt>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::variant<nitro::NullType, SettingsPrompt>& /* result */)>>(std::move(func))) {}
+    inline void call(std::variant<nitro::NullType, SettingsPrompt> result) const noexcept {
       _function->operator()(result);
     }
   private:
-    std::shared_ptr<std::function<void(const std::optional<SettingsPrompt>& /* result */)>> _function;
-  };
-  Func_void_std__optional_SettingsPrompt_ create_Func_void_std__optional_SettingsPrompt_(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__optional_SettingsPrompt__Wrapper wrap_Func_void_std__optional_SettingsPrompt_(Func_void_std__optional_SettingsPrompt_ value) {
-    return Func_void_std__optional_SettingsPrompt__Wrapper(std::move(value));
+    std::unique_ptr<std::function<void(const std::variant<nitro::NullType, SettingsPrompt>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__variant_nitro__NullType__SettingsPrompt_ create_Func_void_std__variant_nitro__NullType__SettingsPrompt_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__variant_nitro__NullType__SettingsPrompt__Wrapper wrap_Func_void_std__variant_nitro__NullType__SettingsPrompt_(Func_void_std__variant_nitro__NullType__SettingsPrompt_ value) noexcept {
+    return Func_void_std__variant_nitro__NullType__SettingsPrompt__Wrapper(std::move(value));
   }
   
   // pragma MARK: std::shared_ptr<Promise<bool>>
@@ -470,10 +611,10 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::shared_ptr<Promise<bool>>`.
    */
   using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
-  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() {
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
     return Promise<bool>::create();
   }
-  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) {
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
     return PromiseHolder<bool>(std::move(promise));
   }
   
@@ -482,7 +623,7 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::vector<PurposeConsent>`.
    */
   using std__vector_PurposeConsent_ = std::vector<PurposeConsent>;
-  inline std::vector<PurposeConsent> create_std__vector_PurposeConsent_(size_t size) {
+  inline std::vector<PurposeConsent> create_std__vector_PurposeConsent_(size_t size) noexcept {
     std::vector<PurposeConsent> vector;
     vector.reserve(size);
     return vector;
@@ -493,111 +634,120 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::vector<PermissionConsent>`.
    */
   using std__vector_PermissionConsent_ = std::vector<PermissionConsent>;
-  inline std::vector<PermissionConsent> create_std__vector_PermissionConsent_(size_t size) {
+  inline std::vector<PermissionConsent> create_std__vector_PermissionConsent_(size_t size) noexcept {
     std::vector<PermissionConsent> vector;
     vector.reserve(size);
     return vector;
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::securiticonsentsdk::HybridConsentSDKSpec>
+  // pragma MARK: std::shared_ptr<HybridConsentSDKSpec>
   /**
-   * Specialized version of `std::shared_ptr<margelo::nitro::securiticonsentsdk::HybridConsentSDKSpec>`.
+   * Specialized version of `std::shared_ptr<HybridConsentSDKSpec>`.
    */
-  using std__shared_ptr_margelo__nitro__securiticonsentsdk__HybridConsentSDKSpec_ = std::shared_ptr<margelo::nitro::securiticonsentsdk::HybridConsentSDKSpec>;
-  std::shared_ptr<margelo::nitro::securiticonsentsdk::HybridConsentSDKSpec> create_std__shared_ptr_margelo__nitro__securiticonsentsdk__HybridConsentSDKSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__securiticonsentsdk__HybridConsentSDKSpec_(std__shared_ptr_margelo__nitro__securiticonsentsdk__HybridConsentSDKSpec_ cppType);
+  using std__shared_ptr_HybridConsentSDKSpec_ = std::shared_ptr<HybridConsentSDKSpec>;
+  std::shared_ptr<HybridConsentSDKSpec> create_std__shared_ptr_HybridConsentSDKSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridConsentSDKSpec_(std__shared_ptr_HybridConsentSDKSpec_ cppType);
   
-  // pragma MARK: std::weak_ptr<margelo::nitro::securiticonsentsdk::HybridConsentSDKSpec>
-  using std__weak_ptr_margelo__nitro__securiticonsentsdk__HybridConsentSDKSpec_ = std::weak_ptr<margelo::nitro::securiticonsentsdk::HybridConsentSDKSpec>;
-  inline std__weak_ptr_margelo__nitro__securiticonsentsdk__HybridConsentSDKSpec_ weakify_std__shared_ptr_margelo__nitro__securiticonsentsdk__HybridConsentSDKSpec_(const std::shared_ptr<margelo::nitro::securiticonsentsdk::HybridConsentSDKSpec>& strong) { return strong; }
+  // pragma MARK: std::weak_ptr<HybridConsentSDKSpec>
+  using std__weak_ptr_HybridConsentSDKSpec_ = std::weak_ptr<HybridConsentSDKSpec>;
+  inline std__weak_ptr_HybridConsentSDKSpec_ weakify_std__shared_ptr_HybridConsentSDKSpec_(const std::shared_ptr<HybridConsentSDKSpec>& strong) noexcept { return strong; }
   
   // pragma MARK: Result<void>
   using Result_void_ = Result<void>;
-  inline Result_void_ create_Result_void_() {
+  inline Result_void_ create_Result_void_() noexcept {
     return Result<void>::withValue();
   }
-  inline Result_void_ create_Result_void_(const std::exception_ptr& error) {
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
     return Result<void>::withError(error);
   }
   
   // 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::shared_ptr<Promise<std::string>>>
   using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) {
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) noexcept {
     return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<AppPermission>>>>
   using Result_std__shared_ptr_Promise_std__vector_AppPermission____ = Result<std::shared_ptr<Promise<std::vector<AppPermission>>>>;
-  inline Result_std__shared_ptr_Promise_std__vector_AppPermission____ create_Result_std__shared_ptr_Promise_std__vector_AppPermission____(const std::shared_ptr<Promise<std::vector<AppPermission>>>& value) {
+  inline Result_std__shared_ptr_Promise_std__vector_AppPermission____ create_Result_std__shared_ptr_Promise_std__vector_AppPermission____(const std::shared_ptr<Promise<std::vector<AppPermission>>>& value) noexcept {
     return Result<std::shared_ptr<Promise<std::vector<AppPermission>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__vector_AppPermission____ create_Result_std__shared_ptr_Promise_std__vector_AppPermission____(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_Promise_std__vector_AppPermission____ create_Result_std__shared_ptr_Promise_std__vector_AppPermission____(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::vector<AppPermission>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<Purpose>>>>
   using Result_std__shared_ptr_Promise_std__vector_Purpose____ = Result<std::shared_ptr<Promise<std::vector<Purpose>>>>;
-  inline Result_std__shared_ptr_Promise_std__vector_Purpose____ create_Result_std__shared_ptr_Promise_std__vector_Purpose____(const std::shared_ptr<Promise<std::vector<Purpose>>>& value) {
+  inline Result_std__shared_ptr_Promise_std__vector_Purpose____ create_Result_std__shared_ptr_Promise_std__vector_Purpose____(const std::shared_ptr<Promise<std::vector<Purpose>>>& value) noexcept {
     return Result<std::shared_ptr<Promise<std::vector<Purpose>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__vector_Purpose____ create_Result_std__shared_ptr_Promise_std__vector_Purpose____(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_Promise_std__vector_Purpose____ create_Result_std__shared_ptr_Promise_std__vector_Purpose____(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::vector<Purpose>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<SDK>>>>
   using Result_std__shared_ptr_Promise_std__vector_SDK____ = Result<std::shared_ptr<Promise<std::vector<SDK>>>>;
-  inline Result_std__shared_ptr_Promise_std__vector_SDK____ create_Result_std__shared_ptr_Promise_std__vector_SDK____(const std::shared_ptr<Promise<std::vector<SDK>>>& value) {
+  inline Result_std__shared_ptr_Promise_std__vector_SDK____ create_Result_std__shared_ptr_Promise_std__vector_SDK____(const std::shared_ptr<Promise<std::vector<SDK>>>& value) noexcept {
     return Result<std::shared_ptr<Promise<std::vector<SDK>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__vector_SDK____ create_Result_std__shared_ptr_Promise_std__vector_SDK____(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_Promise_std__vector_SDK____ create_Result_std__shared_ptr_Promise_std__vector_SDK____(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::vector<SDK>>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<BannerConfig>>>>
-  using Result_std__shared_ptr_Promise_std__optional_BannerConfig____ = Result<std::shared_ptr<Promise<std::optional<BannerConfig>>>>;
-  inline Result_std__shared_ptr_Promise_std__optional_BannerConfig____ create_Result_std__shared_ptr_Promise_std__optional_BannerConfig____(const std::shared_ptr<Promise<std::optional<BannerConfig>>>& value) {
-    return Result<std::shared_ptr<Promise<std::optional<BannerConfig>>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>
+  using Result_std__shared_ptr_Promise_std__unordered_map_std__string__std__string____ = Result<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>;
+  inline Result_std__shared_ptr_Promise_std__unordered_map_std__string__std__string____ create_Result_std__shared_ptr_Promise_std__unordered_map_std__string__std__string____(const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__unordered_map_std__string__std__string____ create_Result_std__shared_ptr_Promise_std__unordered_map_std__string__std__string____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, BannerConfig>>>>
+  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__BannerConfig____ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, BannerConfig>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__BannerConfig____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__BannerConfig____(const std::shared_ptr<Promise<std::variant<nitro::NullType, BannerConfig>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, BannerConfig>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__optional_BannerConfig____ create_Result_std__shared_ptr_Promise_std__optional_BannerConfig____(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::optional<BannerConfig>>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__BannerConfig____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__BannerConfig____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, BannerConfig>>>>::withError(error);
   }
   
-  // pragma MARK: Result<std::optional<CmpSDKOptions>>
-  using Result_std__optional_CmpSDKOptions__ = Result<std::optional<CmpSDKOptions>>;
-  inline Result_std__optional_CmpSDKOptions__ create_Result_std__optional_CmpSDKOptions__(const std::optional<CmpSDKOptions>& value) {
-    return Result<std::optional<CmpSDKOptions>>::withValue(value);
+  // pragma MARK: Result<std::variant<nitro::NullType, CmpSDKOptions>>
+  using Result_std__variant_nitro__NullType__CmpSDKOptions__ = Result<std::variant<nitro::NullType, CmpSDKOptions>>;
+  inline Result_std__variant_nitro__NullType__CmpSDKOptions__ create_Result_std__variant_nitro__NullType__CmpSDKOptions__(const std::variant<nitro::NullType, CmpSDKOptions>& value) noexcept {
+    return Result<std::variant<nitro::NullType, CmpSDKOptions>>::withValue(value);
   }
-  inline Result_std__optional_CmpSDKOptions__ create_Result_std__optional_CmpSDKOptions__(const std::exception_ptr& error) {
-    return Result<std::optional<CmpSDKOptions>>::withError(error);
+  inline Result_std__variant_nitro__NullType__CmpSDKOptions__ create_Result_std__variant_nitro__NullType__CmpSDKOptions__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<nitro::NullType, CmpSDKOptions>>::withError(error);
   }
   
-  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<SettingsPrompt>>>>
-  using Result_std__shared_ptr_Promise_std__optional_SettingsPrompt____ = Result<std::shared_ptr<Promise<std::optional<SettingsPrompt>>>>;
-  inline Result_std__shared_ptr_Promise_std__optional_SettingsPrompt____ create_Result_std__shared_ptr_Promise_std__optional_SettingsPrompt____(const std::shared_ptr<Promise<std::optional<SettingsPrompt>>>& value) {
-    return Result<std::shared_ptr<Promise<std::optional<SettingsPrompt>>>>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<std::variant<nitro::NullType, SettingsPrompt>>>>
+  using Result_std__shared_ptr_Promise_std__variant_nitro__NullType__SettingsPrompt____ = Result<std::shared_ptr<Promise<std::variant<nitro::NullType, SettingsPrompt>>>>;
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__SettingsPrompt____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__SettingsPrompt____(const std::shared_ptr<Promise<std::variant<nitro::NullType, SettingsPrompt>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, SettingsPrompt>>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_std__optional_SettingsPrompt____ create_Result_std__shared_ptr_Promise_std__optional_SettingsPrompt____(const std::exception_ptr& error) {
-    return Result<std::shared_ptr<Promise<std::optional<SettingsPrompt>>>>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__variant_nitro__NullType__SettingsPrompt____ create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__SettingsPrompt____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::variant<nitro::NullType, SettingsPrompt>>>>::withError(error);
   }
   
   // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
   using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
-  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) {
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
     return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
   }
-  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) {
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<bool>>>::withError(error);
   }