@shamilovtim/react-native-nitro-sse 2.3.0

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

@@ -0,0 +1,74 @@
+///
+/// NitroSse-Swift-Cxx-Bridge.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "NitroSse-Swift-Cxx-Bridge.hpp"
+
+// Include C++ implementation defined types
+#include "HybridNitroSseSpecSwift.hpp"
+#include "NitroSse-Swift-Cxx-Umbrella.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::nitrosse::bridge::swift {
+
+  // pragma MARK: std::function<void(const std::unordered_map<std::string, std::string>& /* result */)>
+  Func_void_std__unordered_map_std__string__std__string_ create_Func_void_std__unordered_map_std__string__std__string_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroSse::Func_void_std__unordered_map_std__string__std__string_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::unordered_map<std::string, std::string>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroSse::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void {
+      swiftClosure.call(error);
+    };
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____ create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroSse::Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)]() mutable -> std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>> {
+      auto __result = swiftClosure.call();
+      return __result;
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>& /* result */)>
+  Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___ create_Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroSse::Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<SseEvent>& /* events */)>
+  Func_void_std__vector_SseEvent_ create_Func_void_std__vector_SseEvent_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroSse::Func_void_std__vector_SseEvent_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::vector<SseEvent>& events) mutable -> void {
+      swiftClosure.call(events);
+    };
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridNitroSseSpec>
+  std::shared_ptr<HybridNitroSseSpec> create_std__shared_ptr_HybridNitroSseSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    NitroSse::HybridNitroSseSpec_cxx swiftPart = NitroSse::HybridNitroSseSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::nitrosse::HybridNitroSseSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridNitroSseSpec_(std__shared_ptr_HybridNitroSseSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::nitrosse::HybridNitroSseSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::nitrosse::HybridNitroSseSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridNitroSseSpec\" is not implemented in Swift!");
+    }
+    #endif
+    NitroSse::HybridNitroSseSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+
+} // namespace margelo::nitro::nitrosse::bridge::swift

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

@@ -0,0 +1,415 @@
+///
+/// NitroSse-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `HttpMethod` to properly resolve imports.
+namespace margelo::nitro::nitrosse { enum class HttpMethod; }
+// Forward declaration of `HybridNitroSseSpec` to properly resolve imports.
+namespace margelo::nitro::nitrosse { class HybridNitroSseSpec; }
+// Forward declaration of `SseEventType` to properly resolve imports.
+namespace margelo::nitro::nitrosse { enum class SseEventType; }
+// Forward declaration of `SseEvent` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseEvent; }
+// Forward declaration of `SseMockConfig` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseMockConfig; }
+// Forward declaration of `SseMockEvent` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseMockEvent; }
+// Forward declaration of `SseMockMode` to properly resolve imports.
+namespace margelo::nitro::nitrosse { enum class SseMockMode; }
+// Forward declaration of `SseStats` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseStats; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridNitroSseSpec_cxx` to properly resolve imports.
+namespace NitroSse { class HybridNitroSseSpec_cxx; }
+
+// Include C++ defined types
+#include "HttpMethod.hpp"
+#include "HybridNitroSseSpec.hpp"
+#include "SseEvent.hpp"
+#include "SseEventType.hpp"
+#include "SseMockConfig.hpp"
+#include "SseMockEvent.hpp"
+#include "SseMockMode.hpp"
+#include "SseStats.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::nitrosse::bridge::swift {
+
+  // pragma MARK: std::optional<HttpMethod>
+  /**
+   * Specialized version of `std::optional<HttpMethod>`.
+   */
+  using std__optional_HttpMethod_ = std::optional<HttpMethod>;
+  inline std::optional<HttpMethod> create_std__optional_HttpMethod_(const HttpMethod& value) noexcept {
+    return std::optional<HttpMethod>(value);
+  }
+  inline bool has_value_std__optional_HttpMethod_(const std::optional<HttpMethod>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline HttpMethod get_std__optional_HttpMethod_(const std::optional<HttpMethod>& optional) noexcept {
+    return optional.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) 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) noexcept {
+    std::vector<std::string> keys;
+    keys.reserve(map.size());
+    for (const auto& entry : map) {
+      keys.push_back(entry.first);
+    }
+    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) 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::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) 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.value();
+  }
+  
+  // pragma MARK: std::optional<std::string>
+  /**
+   * 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) 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.value();
+  }
+  
+  // 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) 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.value();
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  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.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::function<void(const std::exception_ptr& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
+   */
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from 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 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* 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));
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____ = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>> call() const noexcept {
+      auto __result = _function->operator()();
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____ create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____ value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string______Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____ = std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>> create_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____() noexcept {
+    return Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>> wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____(std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>&)>`.
+   */
+  using Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___ = std::function<void(const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string____Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string____Wrapper(std::function<void(const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___ create_Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string____Wrapper wrap_Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___(Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___ value) noexcept {
+    return Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string____Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>>
+  /**
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>>`.
+   */
+  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_________ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_________(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>>(value);
+  }
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_________(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_________(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::unordered_map<std::string, std::string>>>>>()>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<SseEventType>
+  /**
+   * Specialized version of `std::optional<SseEventType>`.
+   */
+  using std__optional_SseEventType_ = std::optional<SseEventType>;
+  inline std::optional<SseEventType> create_std__optional_SseEventType_(const SseEventType& value) noexcept {
+    return std::optional<SseEventType>(value);
+  }
+  inline bool has_value_std__optional_SseEventType_(const std::optional<SseEventType>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline SseEventType get_std__optional_SseEventType_(const std::optional<SseEventType>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<std::shared_ptr<AnyMap>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<AnyMap>>`.
+   */
+  using std__optional_std__shared_ptr_AnyMap__ = std::optional<std::shared_ptr<AnyMap>>;
+  inline std::optional<std::shared_ptr<AnyMap>> create_std__optional_std__shared_ptr_AnyMap__(const std::shared_ptr<AnyMap>& value) noexcept {
+    return std::optional<std::shared_ptr<AnyMap>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<AnyMap> get_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::vector<SseMockEvent>
+  /**
+   * Specialized version of `std::vector<SseMockEvent>`.
+   */
+  using std__vector_SseMockEvent_ = std::vector<SseMockEvent>;
+  inline std::vector<SseMockEvent> create_std__vector_SseMockEvent_(size_t size) noexcept {
+    std::vector<SseMockEvent> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<SseMockConfig>
+  /**
+   * Specialized version of `std::optional<SseMockConfig>`.
+   */
+  using std__optional_SseMockConfig_ = std::optional<SseMockConfig>;
+  inline std::optional<SseMockConfig> create_std__optional_SseMockConfig_(const SseMockConfig& value) noexcept {
+    return std::optional<SseMockConfig>(value);
+  }
+  inline bool has_value_std__optional_SseMockConfig_(const std::optional<SseMockConfig>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline SseMockConfig get_std__optional_SseMockConfig_(const std::optional<SseMockConfig>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::vector<SseEvent>
+  /**
+   * Specialized version of `std::vector<SseEvent>`.
+   */
+  using std__vector_SseEvent_ = std::vector<SseEvent>;
+  inline std::vector<SseEvent> create_std__vector_SseEvent_(size_t size) noexcept {
+    std::vector<SseEvent> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<SseEvent>& /* events */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<SseEvent>&)>`.
+   */
+  using Func_void_std__vector_SseEvent_ = std::function<void(const std::vector<SseEvent>& /* events */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<SseEvent>& / * events * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_SseEvent__Wrapper final {
+  public:
+    explicit Func_void_std__vector_SseEvent__Wrapper(std::function<void(const std::vector<SseEvent>& /* events */)>&& func): _function(std::make_unique<std::function<void(const std::vector<SseEvent>& /* events */)>>(std::move(func))) {}
+    inline void call(std::vector<SseEvent> events) const noexcept {
+      _function->operator()(events);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<SseEvent>& /* events */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_SseEvent_ create_Func_void_std__vector_SseEvent_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_SseEvent__Wrapper wrap_Func_void_std__vector_SseEvent_(Func_void_std__vector_SseEvent_ value) noexcept {
+    return Func_void_std__vector_SseEvent__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridNitroSseSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridNitroSseSpec>`.
+   */
+  using std__shared_ptr_HybridNitroSseSpec_ = std::shared_ptr<HybridNitroSseSpec>;
+  std::shared_ptr<HybridNitroSseSpec> create_std__shared_ptr_HybridNitroSseSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridNitroSseSpec_(std__shared_ptr_HybridNitroSseSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridNitroSseSpec>
+  using std__weak_ptr_HybridNitroSseSpec_ = std::weak_ptr<HybridNitroSseSpec>;
+  inline std__weak_ptr_HybridNitroSseSpec_ weakify_std__shared_ptr_HybridNitroSseSpec_(const std::shared_ptr<HybridNitroSseSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+  
+  // pragma MARK: Result<SseStats>
+  using Result_SseStats_ = Result<SseStats>;
+  inline Result_SseStats_ create_Result_SseStats_(const SseStats& value) noexcept {
+    return Result<SseStats>::withValue(value);
+  }
+  inline Result_SseStats_ create_Result_SseStats_(const std::exception_ptr& error) noexcept {
+    return Result<SseStats>::withError(error);
+  }
+  
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  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) noexcept {
+    return Result<bool>::withError(error);
+  }
+
+} // namespace margelo::nitro::nitrosse::bridge::swift

package/nitrogen/generated/ios/NitroSse-Swift-Cxx-Umbrella.hpp

@@ -0,0 +1,74 @@
+///
+/// NitroSse-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `HttpMethod` to properly resolve imports.
+namespace margelo::nitro::nitrosse { enum class HttpMethod; }
+// Forward declaration of `HybridNitroSseSpec` to properly resolve imports.
+namespace margelo::nitro::nitrosse { class HybridNitroSseSpec; }
+// Forward declaration of `SseConfig` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseConfig; }
+// Forward declaration of `SseEventType` to properly resolve imports.
+namespace margelo::nitro::nitrosse { enum class SseEventType; }
+// Forward declaration of `SseEvent` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseEvent; }
+// Forward declaration of `SseMockConfig` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseMockConfig; }
+// Forward declaration of `SseMockEvent` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseMockEvent; }
+// Forward declaration of `SseMockMode` to properly resolve imports.
+namespace margelo::nitro::nitrosse { enum class SseMockMode; }
+// Forward declaration of `SseStats` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseStats; }
+
+// Include C++ defined types
+#include "HttpMethod.hpp"
+#include "HybridNitroSseSpec.hpp"
+#include "SseConfig.hpp"
+#include "SseEvent.hpp"
+#include "SseEventType.hpp"
+#include "SseMockConfig.hpp"
+#include "SseMockEvent.hpp"
+#include "SseMockMode.hpp"
+#include "SseStats.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+// C++ helpers for Swift
+#include "NitroSse-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridNitroSseSpec_cxx` to properly resolve imports.
+namespace NitroSse { class HybridNitroSseSpec_cxx; }
+
+// Include Swift defined types
+#if __has_include("NitroSse-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "NitroSse".
+#include "NitroSse-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<NitroSse/NitroSse-Swift.h>)
+#include <NitroSse/NitroSse-Swift.h>
+#else
+#error NitroSse's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "NitroSse", and try building the app first.
+#endif

package/nitrogen/generated/ios/NitroSseAutolinking.mm

@@ -0,0 +1,33 @@
+///
+/// NitroSseAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "NitroSse-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridNitroSseSpecSwift.hpp"
+
+@interface NitroSseAutolinking : NSObject
+@end
+
+@implementation NitroSseAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::nitrosse;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NitroSse",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridNitroSseSpec> hybridObject = NitroSse::NitroSseAutolinking::createNitroSse();
+      return hybridObject;
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/NitroSseAutolinking.swift

@@ -0,0 +1,26 @@
+///
+/// NitroSseAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
+public final class NitroSseAutolinking {
+  public typealias bridge = margelo.nitro.nitrosse.bridge.swift
+
+  public static func createNitroSse() -> bridge.std__shared_ptr_HybridNitroSseSpec_ {
+    let hybridObject = NitroSse()
+    return { () -> bridge.std__shared_ptr_HybridNitroSseSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isNitroSseRecyclable() -> Bool {
+    return NitroSse.self is any RecyclableView.Type
+  }
+}

package/nitrogen/generated/ios/c++/HybridNitroSseSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridNitroSseSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroSseSpecSwift.hpp"
+
+namespace margelo::nitro::nitrosse {
+} // namespace margelo::nitro::nitrosse