securiti-consent-sdk 1.136.0-7rc → 1.136.0-8rc

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

@@ -66,9 +66,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 */)>
   /**
@@ -81,14 +87,14 @@ 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_unique<std::function<void(bool /* isReady */)>>(std::move(func))) {}
-    inline void call(bool isReady) const {
+    inline void call(bool isReady) const noexcept {
       _function->operator()(isReady);
     }
   private:
     std::unique_ptr<std::function<void(bool /* isReady */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_bool create_Func_void_bool(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) {
+  Func_void_bool create_Func_void_bool(void* _Nonnull 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 +103,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));
   }
   
@@ -115,14 +121,14 @@ 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_unique<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
-    inline void call(std::string result) const {
+    inline void call(std::string result) const noexcept {
       _function->operator()(result);
     }
   private:
     std::unique_ptr<std::function<void(const std::string& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  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) {
+  Func_void_std__string create_Func_void_std__string(void* _Nonnull 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));
   }
   
@@ -137,14 +143,14 @@ 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_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
-    inline void call(std::exception_ptr error) const {
+    inline void call(std::exception_ptr error) const noexcept {
       _function->operator()(error);
     }
   private:
     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* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) {
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull 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 +159,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 +200,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));
   }
   
@@ -200,14 +218,14 @@ 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_unique<std::function<void(const std::vector<AppPermission>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<AppPermission> result) const {
+    inline void call(std::vector<AppPermission> result) const noexcept {
       _function->operator()(result);
     }
   private:
     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* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_AppPermission__Wrapper wrap_Func_void_std__vector_AppPermission_(Func_void_std__vector_AppPermission_ value) {
+  Func_void_std__vector_AppPermission_ create_Func_void_std__vector_AppPermission_(void* _Nonnull 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 +234,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 +245,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 +271,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 +297,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));
   }
   
@@ -285,14 +315,14 @@ 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_unique<std::function<void(const std::vector<Purpose>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<Purpose> result) const {
+    inline void call(std::vector<Purpose> result) const noexcept {
       _function->operator()(result);
     }
   private:
     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* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_Purpose__Wrapper wrap_Func_void_std__vector_Purpose_(Func_void_std__vector_Purpose_ value) {
+  Func_void_std__vector_Purpose_ create_Func_void_std__vector_Purpose_(void* _Nonnull 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 +331,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));
   }
   
@@ -319,14 +349,14 @@ 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_unique<std::function<void(const std::vector<SDK>& /* result */)>>(std::move(func))) {}
-    inline void call(std::vector<SDK> result) const {
+    inline void call(std::vector<SDK> result) const noexcept {
       _function->operator()(result);
     }
   private:
     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* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__vector_SDK__Wrapper wrap_Func_void_std__vector_SDK_(Func_void_std__vector_SDK_ value) {
+  Func_void_std__vector_SDK_ create_Func_void_std__vector_SDK_(void* _Nonnull 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));
   }
   
@@ -335,21 +365,27 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::optional<CustomColors>`.
    */
   using std__optional_CustomColors_ = std::optional<CustomColors>;
-  inline std::optional<CustomColors> create_std__optional_CustomColors_(const CustomColors& value) {
+  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::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,10 +393,10 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
     }
     return keys;
   }
-  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) {
-    return map.at(key);
+  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) {
+  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);
   }
   
@@ -369,28 +405,40 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * 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>
   /**
    * Specialized version of `std::optional<BannerConfig>`.
    */
   using std__optional_BannerConfig_ = std::optional<BannerConfig>;
-  inline std::optional<BannerConfig> create_std__optional_BannerConfig_(const BannerConfig& value) {
+  inline std::optional<BannerConfig> create_std__optional_BannerConfig_(const BannerConfig& value) noexcept {
     return std::optional<BannerConfig>(value);
   }
+  inline bool has_value_std__optional_BannerConfig_(const std::optional<BannerConfig>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline BannerConfig get_std__optional_BannerConfig_(const std::optional<BannerConfig>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::shared_ptr<Promise<std::optional<BannerConfig>>>
   /**
    * Specialized version of `std::shared_ptr<Promise<std::optional<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___() {
+  inline std::shared_ptr<Promise<std::optional<BannerConfig>>> create_std__shared_ptr_Promise_std__optional_BannerConfig___() noexcept {
     return Promise<std::optional<BannerConfig>>::create();
   }
-  inline PromiseHolder<std::optional<BannerConfig>> wrap_std__shared_ptr_Promise_std__optional_BannerConfig___(std::shared_ptr<Promise<std::optional<BannerConfig>>> promise) {
+  inline PromiseHolder<std::optional<BannerConfig>> wrap_std__shared_ptr_Promise_std__optional_BannerConfig___(std::shared_ptr<Promise<std::optional<BannerConfig>>> promise) noexcept {
     return PromiseHolder<std::optional<BannerConfig>>(std::move(promise));
   }
   
@@ -405,14 +453,14 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
   class Func_void_std__optional_BannerConfig__Wrapper final {
   public:
     explicit Func_void_std__optional_BannerConfig__Wrapper(std::function<void(const std::optional<BannerConfig>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<BannerConfig>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<BannerConfig> result) const {
+    inline void call(std::optional<BannerConfig> result) const noexcept {
       _function->operator()(result);
     }
   private:
     std::unique_ptr<std::function<void(const std::optional<BannerConfig>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  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) {
+  Func_void_std__optional_BannerConfig_ create_Func_void_std__optional_BannerConfig_(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_BannerConfig__Wrapper wrap_Func_void_std__optional_BannerConfig_(Func_void_std__optional_BannerConfig_ value) noexcept {
     return Func_void_std__optional_BannerConfig__Wrapper(std::move(value));
   }
   
@@ -421,28 +469,40 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::optional<CmpSDKOptions>`.
    */
   using std__optional_CmpSDKOptions_ = std::optional<CmpSDKOptions>;
-  inline std::optional<CmpSDKOptions> create_std__optional_CmpSDKOptions_(const CmpSDKOptions& value) {
+  inline std::optional<CmpSDKOptions> create_std__optional_CmpSDKOptions_(const CmpSDKOptions& value) noexcept {
     return std::optional<CmpSDKOptions>(value);
   }
+  inline bool has_value_std__optional_CmpSDKOptions_(const std::optional<CmpSDKOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline CmpSDKOptions get_std__optional_CmpSDKOptions_(const std::optional<CmpSDKOptions>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::optional<SettingsPrompt>
   /**
    * Specialized version of `std::optional<SettingsPrompt>`.
    */
   using std__optional_SettingsPrompt_ = std::optional<SettingsPrompt>;
-  inline std::optional<SettingsPrompt> create_std__optional_SettingsPrompt_(const SettingsPrompt& value) {
+  inline std::optional<SettingsPrompt> create_std__optional_SettingsPrompt_(const SettingsPrompt& value) noexcept {
     return std::optional<SettingsPrompt>(value);
   }
+  inline bool has_value_std__optional_SettingsPrompt_(const std::optional<SettingsPrompt>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline SettingsPrompt get_std__optional_SettingsPrompt_(const std::optional<SettingsPrompt>& optional) noexcept {
+    return *optional;
+  }
   
   // pragma MARK: std::shared_ptr<Promise<std::optional<SettingsPrompt>>>
   /**
    * Specialized version of `std::shared_ptr<Promise<std::optional<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___() {
+  inline std::shared_ptr<Promise<std::optional<SettingsPrompt>>> create_std__shared_ptr_Promise_std__optional_SettingsPrompt___() noexcept {
     return Promise<std::optional<SettingsPrompt>>::create();
   }
-  inline PromiseHolder<std::optional<SettingsPrompt>> wrap_std__shared_ptr_Promise_std__optional_SettingsPrompt___(std::shared_ptr<Promise<std::optional<SettingsPrompt>>> promise) {
+  inline PromiseHolder<std::optional<SettingsPrompt>> wrap_std__shared_ptr_Promise_std__optional_SettingsPrompt___(std::shared_ptr<Promise<std::optional<SettingsPrompt>>> promise) noexcept {
     return PromiseHolder<std::optional<SettingsPrompt>>(std::move(promise));
   }
   
@@ -457,14 +517,14 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
   class Func_void_std__optional_SettingsPrompt__Wrapper final {
   public:
     explicit Func_void_std__optional_SettingsPrompt__Wrapper(std::function<void(const std::optional<SettingsPrompt>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<SettingsPrompt>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<SettingsPrompt> result) const {
+    inline void call(std::optional<SettingsPrompt> result) const noexcept {
       _function->operator()(result);
     }
   private:
     std::unique_ptr<std::function<void(const std::optional<SettingsPrompt>& /* result */)>> _function;
   } SWIFT_NONCOPYABLE;
-  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) {
+  Func_void_std__optional_SettingsPrompt_ create_Func_void_std__optional_SettingsPrompt_(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_SettingsPrompt__Wrapper wrap_Func_void_std__optional_SettingsPrompt_(Func_void_std__optional_SettingsPrompt_ value) noexcept {
     return Func_void_std__optional_SettingsPrompt__Wrapper(std::move(value));
   }
   
@@ -473,10 +533,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));
   }
   
@@ -485,7 +545,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;
@@ -496,7 +556,7 @@ 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;
@@ -507,100 +567,100 @@ namespace margelo::nitro::securiticonsentsdk::bridge::swift {
    * Specialized version of `std::shared_ptr<HybridConsentSDKSpec>`.
    */
   using std__shared_ptr_HybridConsentSDKSpec_ = std::shared_ptr<HybridConsentSDKSpec>;
-  std::shared_ptr<HybridConsentSDKSpec> create_std__shared_ptr_HybridConsentSDKSpec_(void* _Nonnull swiftUnsafePointer);
-  void* _Nonnull get_std__shared_ptr_HybridConsentSDKSpec_(std__shared_ptr_HybridConsentSDKSpec_ cppType);
+  std::shared_ptr<HybridConsentSDKSpec> create_std__shared_ptr_HybridConsentSDKSpec_(void* _Nonnull swiftUnsafePointer) noexcept;
+  void* _Nonnull get_std__shared_ptr_HybridConsentSDKSpec_(std__shared_ptr_HybridConsentSDKSpec_ cppType) noexcept;
   
   // 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) { return strong; }
+  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) {
+  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) noexcept {
     return Result<std::shared_ptr<Promise<std::optional<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) {
+  inline Result_std__shared_ptr_Promise_std__optional_BannerConfig____ create_Result_std__shared_ptr_Promise_std__optional_BannerConfig____(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::optional<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) {
+  inline Result_std__optional_CmpSDKOptions__ create_Result_std__optional_CmpSDKOptions__(const std::optional<CmpSDKOptions>& value) noexcept {
     return Result<std::optional<CmpSDKOptions>>::withValue(value);
   }
-  inline Result_std__optional_CmpSDKOptions__ create_Result_std__optional_CmpSDKOptions__(const std::exception_ptr& error) {
+  inline Result_std__optional_CmpSDKOptions__ create_Result_std__optional_CmpSDKOptions__(const std::exception_ptr& error) noexcept {
     return Result<std::optional<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) {
+  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) noexcept {
     return Result<std::shared_ptr<Promise<std::optional<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) {
+  inline Result_std__shared_ptr_Promise_std__optional_SettingsPrompt____ create_Result_std__shared_ptr_Promise_std__optional_SettingsPrompt____(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<Promise<std::optional<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);
   }