@dawidzawada/bonjour-zeroconf 1.0.0

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

@@ -0,0 +1,282 @@
+///
+/// BonjourZeroconf-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `BonjourFail` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { enum class BonjourFail; }
+// Forward declaration of `BonjourListener` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { struct BonjourListener; }
+// Forward declaration of `HybridBonjourZeroconfSpec` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { class HybridBonjourZeroconfSpec; }
+// Forward declaration of `HybridLocalNetworkPermissionSpec` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { class HybridLocalNetworkPermissionSpec; }
+// Forward declaration of `ScanOptions` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { struct ScanOptions; }
+// Forward declaration of `ScanResult` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { struct ScanResult; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridBonjourZeroconfSpec_cxx` to properly resolve imports.
+namespace BonjourZeroconf { class HybridBonjourZeroconfSpec_cxx; }
+// Forward declaration of `HybridLocalNetworkPermissionSpec_cxx` to properly resolve imports.
+namespace BonjourZeroconf { class HybridLocalNetworkPermissionSpec_cxx; }
+
+// Include C++ defined types
+#include "BonjourFail.hpp"
+#include "BonjourListener.hpp"
+#include "HybridBonjourZeroconfSpec.hpp"
+#include "HybridLocalNetworkPermissionSpec.hpp"
+#include "ScanOptions.hpp"
+#include "ScanResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#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::dawidzawada_bonjourzeroconf::bridge::swift {
+
+  // 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;
+  }
+  
+  // pragma MARK: std::optional<ScanOptions>
+  /**
+   * Specialized version of `std::optional<ScanOptions>`.
+   */
+  using std__optional_ScanOptions_ = std::optional<ScanOptions>;
+  inline std::optional<ScanOptions> create_std__optional_ScanOptions_(const ScanOptions& value) noexcept {
+    return std::optional<ScanOptions>(value);
+  }
+  inline bool has_value_std__optional_ScanOptions_(const std::optional<ScanOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ScanOptions get_std__optional_ScanOptions_(const std::optional<ScanOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
+    }
+  private:
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(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;
+  }
+  
+  // pragma MARK: std::vector<ScanResult>
+  /**
+   * Specialized version of `std::vector<ScanResult>`.
+   */
+  using std__vector_ScanResult_ = std::vector<ScanResult>;
+  inline std::vector<ScanResult> create_std__vector_ScanResult_(size_t size) noexcept {
+    std::vector<ScanResult> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<ScanResult>& /* results */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<ScanResult>&)>`.
+   */
+  using Func_void_std__vector_ScanResult_ = std::function<void(const std::vector<ScanResult>& /* results */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<ScanResult>& / * results * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_ScanResult__Wrapper final {
+  public:
+    explicit Func_void_std__vector_ScanResult__Wrapper(std::function<void(const std::vector<ScanResult>& /* results */)>&& func): _function(std::make_unique<std::function<void(const std::vector<ScanResult>& /* results */)>>(std::move(func))) {}
+    inline void call(std::vector<ScanResult> results) const noexcept {
+      _function->operator()(results);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<ScanResult>& /* results */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_ScanResult_ create_Func_void_std__vector_ScanResult_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_ScanResult__Wrapper wrap_Func_void_std__vector_ScanResult_(Func_void_std__vector_ScanResult_ value) noexcept {
+    return Func_void_std__vector_ScanResult__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(bool /* isScanning */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* isScanning */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * isScanning * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* isScanning */)>&& func): _function(std::make_unique<std::function<void(bool /* isScanning */)>>(std::move(func))) {}
+    inline void call(bool isScanning) const noexcept {
+      _function->operator()(isScanning);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* isScanning */)>> _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));
+  }
+  
+  // pragma MARK: std::function<void(BonjourFail /* fail */)>
+  /**
+   * Specialized version of `std::function<void(BonjourFail)>`.
+   */
+  using Func_void_BonjourFail = std::function<void(BonjourFail /* fail */)>;
+  /**
+   * Wrapper class for a `std::function<void(BonjourFail / * fail * /)>`, this can be used from Swift.
+   */
+  class Func_void_BonjourFail_Wrapper final {
+  public:
+    explicit Func_void_BonjourFail_Wrapper(std::function<void(BonjourFail /* fail */)>&& func): _function(std::make_unique<std::function<void(BonjourFail /* fail */)>>(std::move(func))) {}
+    inline void call(int fail) const noexcept {
+      _function->operator()(static_cast<BonjourFail>(fail));
+    }
+  private:
+    std::unique_ptr<std::function<void(BonjourFail /* fail */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_BonjourFail create_Func_void_BonjourFail(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_BonjourFail_Wrapper wrap_Func_void_BonjourFail(Func_void_BonjourFail value) noexcept {
+    return Func_void_BonjourFail_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridBonjourZeroconfSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridBonjourZeroconfSpec>`.
+   */
+  using std__shared_ptr_HybridBonjourZeroconfSpec_ = std::shared_ptr<HybridBonjourZeroconfSpec>;
+  std::shared_ptr<HybridBonjourZeroconfSpec> create_std__shared_ptr_HybridBonjourZeroconfSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridBonjourZeroconfSpec_(std__shared_ptr_HybridBonjourZeroconfSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridBonjourZeroconfSpec>
+  using std__weak_ptr_HybridBonjourZeroconfSpec_ = std::weak_ptr<HybridBonjourZeroconfSpec>;
+  inline std__weak_ptr_HybridBonjourZeroconfSpec_ weakify_std__shared_ptr_HybridBonjourZeroconfSpec_(const std::shared_ptr<HybridBonjourZeroconfSpec>& 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<BonjourListener>
+  using Result_BonjourListener_ = Result<BonjourListener>;
+  inline Result_BonjourListener_ create_Result_BonjourListener_(const BonjourListener& value) noexcept {
+    return Result<BonjourListener>::withValue(value);
+  }
+  inline Result_BonjourListener_ create_Result_BonjourListener_(const std::exception_ptr& error) noexcept {
+    return Result<BonjourListener>::withError(error);
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * 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__() noexcept {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
+  // 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::shared_ptr<HybridLocalNetworkPermissionSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridLocalNetworkPermissionSpec>`.
+   */
+  using std__shared_ptr_HybridLocalNetworkPermissionSpec_ = std::shared_ptr<HybridLocalNetworkPermissionSpec>;
+  std::shared_ptr<HybridLocalNetworkPermissionSpec> create_std__shared_ptr_HybridLocalNetworkPermissionSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridLocalNetworkPermissionSpec_(std__shared_ptr_HybridLocalNetworkPermissionSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridLocalNetworkPermissionSpec>
+  using std__weak_ptr_HybridLocalNetworkPermissionSpec_ = std::weak_ptr<HybridLocalNetworkPermissionSpec>;
+  inline std__weak_ptr_HybridLocalNetworkPermissionSpec_ weakify_std__shared_ptr_HybridLocalNetworkPermissionSpec_(const std::shared_ptr<HybridLocalNetworkPermissionSpec>& strong) noexcept { return strong; }
+  
+  // 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) 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) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
+  }
+
+} // namespace margelo::nitro::dawidzawada_bonjourzeroconf::bridge::swift

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

@@ -0,0 +1,65 @@
+///
+/// BonjourZeroconf-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `BonjourFail` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { enum class BonjourFail; }
+// Forward declaration of `BonjourListener` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { struct BonjourListener; }
+// Forward declaration of `HybridBonjourZeroconfSpec` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { class HybridBonjourZeroconfSpec; }
+// Forward declaration of `HybridLocalNetworkPermissionSpec` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { class HybridLocalNetworkPermissionSpec; }
+// Forward declaration of `ScanOptions` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { struct ScanOptions; }
+// Forward declaration of `ScanResult` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { struct ScanResult; }
+
+// Include C++ defined types
+#include "BonjourFail.hpp"
+#include "BonjourListener.hpp"
+#include "HybridBonjourZeroconfSpec.hpp"
+#include "HybridLocalNetworkPermissionSpec.hpp"
+#include "ScanOptions.hpp"
+#include "ScanResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+// C++ helpers for Swift
+#include "BonjourZeroconf-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 `HybridBonjourZeroconfSpec_cxx` to properly resolve imports.
+namespace BonjourZeroconf { class HybridBonjourZeroconfSpec_cxx; }
+// Forward declaration of `HybridLocalNetworkPermissionSpec_cxx` to properly resolve imports.
+namespace BonjourZeroconf { class HybridLocalNetworkPermissionSpec_cxx; }
+
+// Include Swift defined types
+#if __has_include("BonjourZeroconf-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 "BonjourZeroconf".
+#include "BonjourZeroconf-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<BonjourZeroconf/BonjourZeroconf-Swift.h>)
+#include <BonjourZeroconf/BonjourZeroconf-Swift.h>
+#else
+#error BonjourZeroconf's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "BonjourZeroconf", and try building the app first.
+#endif

package/nitrogen/generated/ios/BonjourZeroconfAutolinking.mm

@@ -0,0 +1,41 @@
+///
+/// BonjourZeroconfAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "BonjourZeroconf-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridBonjourZeroconfSpecSwift.hpp"
+#include "HybridLocalNetworkPermissionSpecSwift.hpp"
+
+@interface BonjourZeroconfAutolinking : NSObject
+@end
+
+@implementation BonjourZeroconfAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::dawidzawada_bonjourzeroconf;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "BonjourZeroconf",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridBonjourZeroconfSpec> hybridObject = BonjourZeroconf::BonjourZeroconfAutolinking::createBonjourZeroconf();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "LocalNetworkPermission",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridLocalNetworkPermissionSpec> hybridObject = BonjourZeroconf::BonjourZeroconfAutolinking::createLocalNetworkPermission();
+      return hybridObject;
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/BonjourZeroconfAutolinking.swift

@@ -0,0 +1,40 @@
+///
+/// BonjourZeroconfAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+public final class BonjourZeroconfAutolinking {
+  public typealias bridge = margelo.nitro.dawidzawada_bonjourzeroconf.bridge.swift
+
+  /**
+   * Creates an instance of a Swift class that implements `HybridBonjourZeroconfSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridBonjourZeroconfSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `BonjourZeroconf`).
+   */
+  public static func createBonjourZeroconf() -> bridge.std__shared_ptr_HybridBonjourZeroconfSpec_ {
+    let hybridObject = BonjourZeroconf()
+    return { () -> bridge.std__shared_ptr_HybridBonjourZeroconfSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridLocalNetworkPermissionSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridLocalNetworkPermissionSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `LocalNetworkPermission`).
+   */
+  public static func createLocalNetworkPermission() -> bridge.std__shared_ptr_HybridLocalNetworkPermissionSpec_ {
+    let hybridObject = LocalNetworkPermission()
+    return { () -> bridge.std__shared_ptr_HybridLocalNetworkPermissionSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+}

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

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

package/nitrogen/generated/ios/c++/HybridBonjourZeroconfSpecSwift.hpp

@@ -0,0 +1,120 @@
+///
+/// HybridBonjourZeroconfSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridBonjourZeroconfSpec.hpp"
+
+// Forward declaration of `HybridBonjourZeroconfSpec_cxx` to properly resolve imports.
+namespace BonjourZeroconf { class HybridBonjourZeroconfSpec_cxx; }
+
+// Forward declaration of `ScanOptions` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { struct ScanOptions; }
+// Forward declaration of `BonjourListener` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { struct BonjourListener; }
+// Forward declaration of `ScanResult` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { struct ScanResult; }
+// Forward declaration of `BonjourFail` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { enum class BonjourFail; }
+
+#include <string>
+#include "ScanOptions.hpp"
+#include <optional>
+#include "BonjourListener.hpp"
+#include <functional>
+#include "ScanResult.hpp"
+#include <vector>
+#include "BonjourFail.hpp"
+
+#include "BonjourZeroconf-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::dawidzawada_bonjourzeroconf {
+
+  /**
+   * The C++ part of HybridBonjourZeroconfSpec_cxx.swift.
+   *
+   * HybridBonjourZeroconfSpecSwift (C++) accesses HybridBonjourZeroconfSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridBonjourZeroconfSpec_cxx can directly inherit from the C++ class HybridBonjourZeroconfSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridBonjourZeroconfSpecSwift: public virtual HybridBonjourZeroconfSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridBonjourZeroconfSpecSwift(const BonjourZeroconf::HybridBonjourZeroconfSpec_cxx& swiftPart):
+      HybridObject(HybridBonjourZeroconfSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline BonjourZeroconf::HybridBonjourZeroconfSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline bool getIsScanning() noexcept override {
+      return _swiftPart.isScanning();
+    }
+
+  public:
+    // Methods
+    inline void scan(const std::string& type, const std::string& domain, const std::optional<ScanOptions>& options) override {
+      auto __result = _swiftPart.scan(type, domain, options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void stop() override {
+      auto __result = _swiftPart.stop();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline BonjourListener listenForScanResults(const std::function<void(const std::vector<ScanResult>& /* results */)>& onResult) override {
+      auto __result = _swiftPart.listenForScanResults(onResult);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline BonjourListener listenForScanState(const std::function<void(bool /* isScanning */)>& onChange) override {
+      auto __result = _swiftPart.listenForScanState(onChange);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline BonjourListener listenForScanFail(const std::function<void(BonjourFail /* fail */)>& onFail) override {
+      auto __result = _swiftPart.listenForScanFail(onFail);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    BonjourZeroconf::HybridBonjourZeroconfSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::dawidzawada_bonjourzeroconf

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

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

package/nitrogen/generated/ios/c++/HybridLocalNetworkPermissionSpecSwift.hpp

@@ -0,0 +1,87 @@
+///
+/// HybridLocalNetworkPermissionSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridLocalNetworkPermissionSpec.hpp"
+
+// Forward declaration of `HybridLocalNetworkPermissionSpec_cxx` to properly resolve imports.
+namespace BonjourZeroconf { class HybridLocalNetworkPermissionSpec_cxx; }
+
+// Forward declaration of `BonjourListener` to properly resolve imports.
+namespace margelo::nitro::dawidzawada_bonjourzeroconf { struct BonjourListener; }
+
+#include <NitroModules/Promise.hpp>
+#include "BonjourListener.hpp"
+#include <functional>
+
+#include "BonjourZeroconf-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::dawidzawada_bonjourzeroconf {
+
+  /**
+   * The C++ part of HybridLocalNetworkPermissionSpec_cxx.swift.
+   *
+   * HybridLocalNetworkPermissionSpecSwift (C++) accesses HybridLocalNetworkPermissionSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridLocalNetworkPermissionSpec_cxx can directly inherit from the C++ class HybridLocalNetworkPermissionSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridLocalNetworkPermissionSpecSwift: public virtual HybridLocalNetworkPermissionSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridLocalNetworkPermissionSpecSwift(const BonjourZeroconf::HybridLocalNetworkPermissionSpec_cxx& swiftPart):
+      HybridObject(HybridLocalNetworkPermissionSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline BonjourZeroconf::HybridLocalNetworkPermissionSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<bool>> requestPermission() override {
+      auto __result = _swiftPart.requestPermission();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline BonjourListener listenForPermission(const std::function<void(bool /* granted */)>& onChange) override {
+      auto __result = _swiftPart.listenForPermission(onChange);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    BonjourZeroconf::HybridLocalNetworkPermissionSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::dawidzawada_bonjourzeroconf