react-native-zeroconf 0.17.2 → 1.0.0-rc.1

package/cpp/dnssd/DnssdBackend.h

@@ -0,0 +1,114 @@
+// The backend for the dns_sd API: Apple's system mDNSResponder (iOS, macOS, tvOS) and the mDNSResponder
+// embedded in the library on Android (DNSSD).
+#pragma once
+
+#include "../Backend.h"
+#include "Executor.h"
+
+#include <map>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+
+namespace rnzeroconf {
+
+struct DnssdScan;
+struct DnssdResolve;
+struct DnssdPublication;
+
+class DnssdBackend : public Backend, public std::enable_shared_from_this<DnssdBackend> {
+ public:
+  // Callbacks of events run on the executor's thread
+  static std::shared_ptr<DnssdBackend> Create(std::shared_ptr<Executor> executor, Events events);
+
+  void Scan(
+      const std::string &scanId,
+      const std::string &type,
+      const std::string &protocol,
+      const std::string &domain,
+      const ScanOptions &options) override;
+  void Stop(const std::string &scanId) override;
+
+  void Publish(
+      const std::string &type,
+      const std::string &protocol,
+      const std::string &domain,
+      const std::string &name,
+      uint16_t port,
+      const TxtPairs &txt,
+      const PublishOptions &options,
+      ServiceCallback resolve,
+      ErrorCallback reject) override;
+  void Unpublish(const std::string &name, ServiceCallback resolve, ErrorCallback reject) override;
+  void Update(const std::string &name, const TxtPairs &txt, ServiceCallback resolve, ErrorCallback reject) override;
+
+  void ResolveService(
+      const std::string &name,
+      const std::string &type,
+      const std::string &protocol,
+      const std::string &domain,
+      const ResolveOptions &options,
+      ServiceCallback resolve,
+      ErrorCallback reject) override;
+
+  void Shutdown() override;
+
+  // Runs a task on the executor's thread
+  void Post(Executor::Task task);
+
+  // dns_sd callbacks with their data copied, on the executor's thread
+  void OnBrowse(const std::shared_ptr<DnssdScan> &scan, DNSServiceFlags flags, DNSServiceErrorType error, const std::optional<std::string> &name, const std::string &regtype, const std::string &domain);
+  void OnResolve(const std::shared_ptr<DnssdResolve> &resolve, DNSServiceErrorType error, const std::string &host, uint16_t port, const std::string &txt);
+  void OnAddress(const std::shared_ptr<DnssdResolve> &resolve, DNSServiceFlags flags, DNSServiceErrorType error, const std::string &address);
+  void OnTxt(const std::shared_ptr<DnssdResolve> &resolve, DNSServiceFlags flags, DNSServiceErrorType error, const std::string &data);
+  void OnRegister(const std::shared_ptr<DnssdPublication> &publication, DNSServiceFlags flags, DNSServiceErrorType error, const std::optional<std::string> &name);
+
+ private:
+  DnssdBackend(std::shared_ptr<Executor> executor, Events events);
+
+  // Runs on the executor's thread, while the backend exists
+  void Run(std::function<void(DnssdBackend &)> task);
+
+  void StopScan(const std::string &scanId);
+  void StartResolve(const std::shared_ptr<DnssdScan> &scan, const std::string &name, const std::string &regtype, const std::string &domain);
+  void BeginResolve(const std::shared_ptr<DnssdResolve> &resolve);
+  void ResolveTimedOut(const std::shared_ptr<DnssdResolve> &resolve);
+  void ScheduleEmit(const std::shared_ptr<DnssdResolve> &resolve);
+  void EmitResolve(const std::shared_ptr<DnssdResolve> &resolve);
+  void WatchTxt(const std::shared_ptr<DnssdResolve> &resolve);
+  void FailResolve(const std::shared_ptr<DnssdResolve> &resolve, const Error &error);
+  void CancelResolve(const std::shared_ptr<DnssdResolve> &resolve);
+  void EndSingleResolve(const std::shared_ptr<DnssdResolve> &resolve);
+  bool IsActive(const std::shared_ptr<DnssdResolve> &resolve) const;
+  // Deallocates a ref on the next turn, its callback may be running. keepAlive outlives the ref
+  void DeallocateLater(DNSServiceRef &ref, std::shared_ptr<void> keepAlive);
+  bool IsNameInUse(const std::string &name) const;
+  Service PublishedService(const DnssdPublication &publication) const;
+  void SendError(const std::string &scanId, const Error &error);
+
+  std::shared_ptr<Executor> executor_;
+  Events events_;
+  std::map<std::string, std::shared_ptr<DnssdScan>> scans_;
+  // Registered, keyed by the name actually used, which can differ from the requested one
+  std::map<std::string, std::shared_ptr<DnssdPublication>> published_;
+  // Waiting for the register callback
+  std::set<std::shared_ptr<DnssdPublication>> pending_;
+  // resolveService() calls in flight
+  std::set<std::shared_ptr<DnssdResolve>> singleResolves_;
+};
+
+// Shared with the harness and the module
+
+// Readable description of a DNSServiceErrorType
+std::string DescribeDnssdError(DNSServiceErrorType code);
+// { domain: 'DNSSD', code, message: "<action> <serviceName> failed: <description>" }
+Error DnssdError(DNSServiceErrorType code, const std::string &action, const std::string &serviceName = "");
+// TXT record bytes <-> ordered pairs. Entries longer than 255 bytes are left out and their keys listed in tooLong
+std::string EncodeTxt(const TxtPairs &txt, std::vector<std::string> *tooLong);
+TxtPairs DecodeTxt(const void *record, uint16_t length);
+// The index of a network interface by name ("en0"), kDNSServiceInterfaceIndexAny for an empty name.
+// False when the interface doesn't exist
+bool InterfaceIndex(const std::string &name, uint32_t &index);
+
+} // namespace rnzeroconf

package/cpp/dnssd/Executor.h

@@ -0,0 +1,28 @@
+// The serial thread a dns_sd backend runs on: every call into the backend and every dns_sd callback is
+// delivered on it, so the backend needs no locks. Apple: a dispatch queue. Android: the embedded
+// mDNSResponder's thread.
+#pragma once
+
+#include <dns_sd.h>
+
+#include <cstdint>
+#include <functional>
+
+namespace rnzeroconf {
+
+class Executor {
+ public:
+  using Task = std::function<void()>;
+  using TimerId = uint64_t;
+
+  virtual ~Executor() = default;
+  // Runs the task on the executor's thread, after the current one
+  virtual void Post(Task task) = 0;
+  // Runs the task after a delay, unless cancelled first. Ids are never 0
+  virtual TimerId PostDelayed(double seconds, Task task) = 0;
+  virtual void Cancel(TimerId timer) = 0;
+  // Delivers the callbacks of a new DNSServiceRef on the executor's thread
+  virtual void Attach(DNSServiceRef ref) = 0;
+};
+
+} // namespace rnzeroconf

package/cpp/embedded/EmbeddedExecutor.cpp

@@ -0,0 +1,124 @@
+#include "EmbeddedExecutor.h"
+
+#include <utility>
+
+// The embedded responder's entry points (mDNSPosix/PosixDaemon.c)
+extern "C" {
+int init();
+int loop();
+void stopLoop();
+void lockCore();
+void unlockCore();
+}
+
+namespace rnzeroconf {
+
+// Started by the first use and kept for the life of the process: the responder can only be initialized
+// once at a time, and backends release their last reference from the executor's own tasks
+std::shared_ptr<EmbeddedExecutor> EmbeddedExecutor::Shared() {
+  static std::shared_ptr<EmbeddedExecutor> executor(new EmbeddedExecutor());
+  return executor;
+}
+
+EmbeddedExecutor::EmbeddedExecutor() {
+  responder_ = std::thread([this] { RunResponder(); });
+  worker_ = std::thread([this] { RunTasks(); });
+}
+
+EmbeddedExecutor::~EmbeddedExecutor() {
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    stopping_ = true;
+  }
+  changed_.notify_all();
+  // The last reference can go away in one of the executor's own tasks
+  if (worker_.get_id() == std::this_thread::get_id()) {
+    worker_.detach();
+  } else {
+    worker_.join();
+  }
+  stopLoop();
+  responder_.join();
+}
+
+void EmbeddedExecutor::RunResponder() {
+  int error = init();
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    started_ = true;
+    startError_ = error;
+  }
+  changed_.notify_all();
+  if (error == 0) {
+    loop();
+  }
+}
+
+int EmbeddedExecutor::StartError() const {
+  return startError_;
+}
+
+void EmbeddedExecutor::RunTasks() {
+  std::unique_lock<std::mutex> lock(mutex_);
+  // dns_sd calls need the responder initialized
+  changed_.wait(lock, [this] { return started_ || stopping_; });
+  while (true) {
+    Task task;
+    if (!tasks_.empty()) {
+      task = std::move(tasks_.front());
+      tasks_.pop_front();
+    } else {
+      auto next = timers_.end();
+      for (auto it = timers_.begin(); it != timers_.end(); ++it) {
+        if (next == timers_.end() || it->second.due < next->second.due) {
+          next = it;
+        }
+      }
+      if (stopping_) {
+        return;
+      }
+      if (next == timers_.end()) {
+        changed_.wait(lock);
+        continue;
+      }
+      if (Clock::now() < next->second.due) {
+        changed_.wait_until(lock, next->second.due);
+        continue;
+      }
+      task = std::move(next->second.task);
+      timers_.erase(next);
+    }
+    lock.unlock();
+    lockCore();
+    task();
+    // What the task holds is released under the core lock, outside the queue's
+    task = nullptr;
+    unlockCore();
+    lock.lock();
+  }
+}
+
+void EmbeddedExecutor::Post(Task task) {
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    tasks_.push_back(std::move(task));
+  }
+  changed_.notify_all();
+}
+
+Executor::TimerId EmbeddedExecutor::PostDelayed(double seconds, Task task) {
+  TimerId id = ++nextTimer_;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    timers_[id] = Timer{Clock::now() + std::chrono::milliseconds(static_cast<int64_t>(seconds * 1000)), std::move(task)};
+  }
+  changed_.notify_all();
+  return id;
+}
+
+void EmbeddedExecutor::Cancel(TimerId timer) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  timers_.erase(timer);
+}
+
+} // namespace rnzeroconf

package/cpp/embedded/EmbeddedExecutor.h

@@ -0,0 +1,57 @@
+// Executor for the mDNSResponder embedded in the library (Android DNSSD). The responder runs its event
+// loop on a thread of its own and delivers dns_sd callbacks there; the backend runs on a second thread,
+// each task holding the responder's core lock, which every call into it requires.
+#pragma once
+
+#include "../dnssd/Executor.h"
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <deque>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <thread>
+
+namespace rnzeroconf {
+
+class EmbeddedExecutor : public Executor {
+ public:
+  // The responder is a process-wide singleton, started by the first use
+  static std::shared_ptr<EmbeddedExecutor> Shared();
+  ~EmbeddedExecutor() override;
+
+  void Post(Task task) override;
+  TimerId PostDelayed(double seconds, Task task) override;
+  void Cancel(TimerId timer) override;
+  // The responder delivers callbacks by itself
+  void Attach(DNSServiceRef) override {}
+
+  // The error of the responder's start, 0 when it runs
+  int StartError() const;
+
+ private:
+  using Clock = std::chrono::steady_clock;
+  struct Timer {
+    Clock::time_point due;
+    Task task;
+  };
+
+  EmbeddedExecutor();
+  void RunResponder();
+  void RunTasks();
+
+  std::mutex mutex_;
+  std::condition_variable changed_;
+  std::deque<Task> tasks_;
+  std::map<TimerId, Timer> timers_;
+  std::atomic<TimerId> nextTimer_{0};
+  bool started_ = false;
+  int startError_ = 0;
+  bool stopping_ = false;
+  std::thread responder_;
+  std::thread worker_;
+};
+
+} // namespace rnzeroconf

package/ios/ZeroconfOnLoad.mm

@@ -0,0 +1,34 @@
+// Registers the C++ module on Apple platforms: one dns_sd backend on a private queue, and the
+// Local Network check of Network.framework
+#import <Foundation/Foundation.h>
+#import <ReactCommon/CxxTurboModuleUtils.h>
+
+#include "../cpp/ZeroconfModule.h"
+#include "../cpp/apple/DispatchExecutor.h"
+#include "../cpp/apple/LocalNetworkAccess.h"
+#include "../cpp/dnssd/DnssdBackend.h"
+
+using namespace facebook::react;
+
+@interface ZeroconfOnLoad : NSObject
+@end
+
+@implementation ZeroconfOnLoad
+
++ (void)load
+{
+  registerCxxModuleToGlobalModuleMap(
+      std::string(ZeroconfModule::kModuleName),
+      [](std::shared_ptr<CallInvoker> jsInvoker) {
+        ZeroconfPlatform platform;
+        // One mDNS stack on Apple platforms, implType is Android's
+        platform.backendKey = [](const std::string &) { return std::string("dnssd"); };
+        platform.createBackend = [](const std::string &, rnzeroconf::Events events) -> std::shared_ptr<rnzeroconf::Backend> {
+          return rnzeroconf::DnssdBackend::Create(std::make_shared<rnzeroconf::DispatchExecutor>("com.balthazargronon.rnzeroconf"), std::move(events));
+        };
+        platform.checkLocalNetworkAccess = rnzeroconf::CheckLocalNetworkAccess;
+        return std::make_shared<ZeroconfModule>(jsInvoker, std::move(platform));
+      });
+}
+
+@end

package/ios/generated/ReactCodegen/RNZeroconfSpec/RNZeroconfSpec-generated.mm

@@ -0,0 +1,140 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#import "RNZeroconfSpec.h"
+
+
+@implementation NativeZeroconfSpecBase
+- (void)emitOnStart:(NSDictionary *)value
+{
+  _eventEmitterCallback("onStart", value);
+}
+- (void)emitOnStop:(NSDictionary *)value
+{
+  _eventEmitterCallback("onStop", value);
+}
+- (void)emitOnFound:(NSDictionary *)value
+{
+  _eventEmitterCallback("onFound", value);
+}
+- (void)emitOnRemove:(NSDictionary *)value
+{
+  _eventEmitterCallback("onRemove", value);
+}
+- (void)emitOnResolved:(NSDictionary *)value
+{
+  _eventEmitterCallback("onResolved", value);
+}
+- (void)emitOnError:(NSDictionary *)value
+{
+  _eventEmitterCallback("onError", value);
+}
+- (void)emitOnPublished:(NSDictionary *)value
+{
+  _eventEmitterCallback("onPublished", value);
+}
+- (void)emitOnUnpublished:(NSDictionary *)value
+{
+  _eventEmitterCallback("onUnpublished", value);
+}
+
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper
+{
+  _eventEmitterCallback = std::move(eventEmitterCallbackWrapper->_eventEmitterCallback);
+}
+@end
+
+@implementation RCTCxxConvert (NativeZeroconf_NativeScanOptions)
++ (RCTManagedPointer *)JS_NativeZeroconf_NativeScanOptions:(id)json
+{
+  return facebook::react::managedPointer<JS::NativeZeroconf::NativeScanOptions>(json);
+}
+@end
+@implementation RCTCxxConvert (NativeZeroconf_NativePublishOptions)
++ (RCTManagedPointer *)JS_NativeZeroconf_NativePublishOptions:(id)json
+{
+  return facebook::react::managedPointer<JS::NativeZeroconf::NativePublishOptions>(json);
+}
+@end
+@implementation RCTCxxConvert (NativeZeroconf_NativeResolveOptions)
++ (RCTManagedPointer *)JS_NativeZeroconf_NativeResolveOptions:(id)json
+{
+  return facebook::react::managedPointer<JS::NativeZeroconf::NativeResolveOptions>(json);
+}
+@end
+namespace facebook::react {
+  
+    static facebook::jsi::Value __hostFunction_NativeZeroconfSpecJSI_scan(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "scan", @selector(scan:type:protocol:domain:implType:options:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeZeroconfSpecJSI_stop(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "stop", @selector(stop:implType:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeZeroconfSpecJSI_registerService(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "registerService", @selector(registerService:protocol:domain:name:port:txt:implType:options:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeZeroconfSpecJSI_updateService(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "updateService", @selector(updateService:txt:implType:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeZeroconfSpecJSI_unregisterService(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "unregisterService", @selector(unregisterService:implType:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeZeroconfSpecJSI_resolveService(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "resolveService", @selector(resolveService:type:protocol:domain:implType:options:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeZeroconfSpecJSI_checkLocalNetworkAccess(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "checkLocalNetworkAccess", @selector(checkLocalNetworkAccess:timeout:resolve:reject:), args, count);
+    }
+
+  NativeZeroconfSpecJSI::NativeZeroconfSpecJSI(const ObjCTurboModule::InitParams &params)
+    : ObjCTurboModule(params) {
+      
+        methodMap_["scan"] = MethodMetadata {6, __hostFunction_NativeZeroconfSpecJSI_scan};
+        setMethodArgConversionSelector(@"scan", 5, @"JS_NativeZeroconf_NativeScanOptions:");
+        
+        methodMap_["stop"] = MethodMetadata {2, __hostFunction_NativeZeroconfSpecJSI_stop};
+        
+        
+        methodMap_["registerService"] = MethodMetadata {8, __hostFunction_NativeZeroconfSpecJSI_registerService};
+        setMethodArgConversionSelector(@"registerService", 7, @"JS_NativeZeroconf_NativePublishOptions:");
+        
+        methodMap_["updateService"] = MethodMetadata {3, __hostFunction_NativeZeroconfSpecJSI_updateService};
+        
+        
+        methodMap_["unregisterService"] = MethodMetadata {2, __hostFunction_NativeZeroconfSpecJSI_unregisterService};
+        
+        
+        methodMap_["resolveService"] = MethodMetadata {6, __hostFunction_NativeZeroconfSpecJSI_resolveService};
+        setMethodArgConversionSelector(@"resolveService", 5, @"JS_NativeZeroconf_NativeResolveOptions:");
+        
+        methodMap_["checkLocalNetworkAccess"] = MethodMetadata {2, __hostFunction_NativeZeroconfSpecJSI_checkLocalNetworkAccess};
+        
+        eventEmitterMap_["onStart"] = std::make_shared<AsyncEventEmitter<id>>();
+        eventEmitterMap_["onStop"] = std::make_shared<AsyncEventEmitter<id>>();
+        eventEmitterMap_["onFound"] = std::make_shared<AsyncEventEmitter<id>>();
+        eventEmitterMap_["onRemove"] = std::make_shared<AsyncEventEmitter<id>>();
+        eventEmitterMap_["onResolved"] = std::make_shared<AsyncEventEmitter<id>>();
+        eventEmitterMap_["onError"] = std::make_shared<AsyncEventEmitter<id>>();
+        eventEmitterMap_["onPublished"] = std::make_shared<AsyncEventEmitter<id>>();
+        eventEmitterMap_["onUnpublished"] = std::make_shared<AsyncEventEmitter<id>>();
+        setEventEmitterCallback([&](const std::string &name, id value) {
+          static_cast<AsyncEventEmitter<id> &>(*eventEmitterMap_[name]).emit(value);
+        });
+  }
+} // namespace facebook::react

package/ios/generated/ReactCodegen/RNZeroconfSpec/RNZeroconfSpec.h

@@ -0,0 +1,189 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#ifndef __cplusplus
+#error This file must be compiled as Obj-C++. If you are importing it, you must change your file extension to .mm.
+#endif
+
+// Avoid multiple includes of RNZeroconfSpec symbols
+#ifndef RNZeroconfSpec_H
+#define RNZeroconfSpec_H
+
+#import <Foundation/Foundation.h>
+#import <RCTRequired/RCTRequired.h>
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <RCTTypeSafety/RCTTypedModuleConstants.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTCxxConvert.h>
+#import <React/RCTManagedPointer.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <optional>
+#import <vector>
+
+
+NS_ASSUME_NONNULL_BEGIN
+namespace JS {
+  namespace NativeZeroconf {
+    struct NativeScanOptions {
+      std::optional<double> resolveTimeout() const;
+      NSString *subtype() const;
+      NSString *networkInterface() const;
+
+      NativeScanOptions(NSDictionary *const v) : _v(v) {}
+    private:
+      NSDictionary *_v;
+    };
+  }
+}
+
+@interface RCTCxxConvert (NativeZeroconf_NativeScanOptions)
++ (RCTManagedPointer *)JS_NativeZeroconf_NativeScanOptions:(id)json;
+@end
+namespace JS {
+  namespace NativeZeroconf {
+    struct NativePublishOptions {
+      std::optional<facebook::react::LazyVector<NSString *>> subtypes() const;
+      NSString *networkInterface() const;
+
+      NativePublishOptions(NSDictionary *const v) : _v(v) {}
+    private:
+      NSDictionary *_v;
+    };
+  }
+}
+
+@interface RCTCxxConvert (NativeZeroconf_NativePublishOptions)
++ (RCTManagedPointer *)JS_NativeZeroconf_NativePublishOptions:(id)json;
+@end
+namespace JS {
+  namespace NativeZeroconf {
+    struct NativeResolveOptions {
+      std::optional<double> timeout() const;
+      NSString *networkInterface() const;
+
+      NativeResolveOptions(NSDictionary *const v) : _v(v) {}
+    private:
+      NSDictionary *_v;
+    };
+  }
+}
+
+@interface RCTCxxConvert (NativeZeroconf_NativeResolveOptions)
++ (RCTManagedPointer *)JS_NativeZeroconf_NativeResolveOptions:(id)json;
+@end
+@protocol NativeZeroconfSpec <RCTBridgeModule, RCTTurboModule>
+
+- (void)scan:(NSString *)scanId
+        type:(NSString *)type
+    protocol:(NSString *)protocol
+      domain:(NSString *)domain
+    implType:(NSString *)implType
+     options:(JS::NativeZeroconf::NativeScanOptions &)options;
+- (void)stop:(NSString *)scanId
+    implType:(NSString *)implType;
+- (void)registerService:(NSString *)type
+               protocol:(NSString *)protocol
+                 domain:(NSString *)domain
+                   name:(NSString *)name
+                   port:(double)port
+                    txt:(NSArray *)txt
+               implType:(NSString *)implType
+                options:(JS::NativeZeroconf::NativePublishOptions &)options
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject;
+- (void)updateService:(NSString *)name
+                  txt:(NSArray *)txt
+             implType:(NSString *)implType
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject;
+- (void)unregisterService:(NSString *)name
+                 implType:(NSString *)implType
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject;
+- (void)resolveService:(NSString *)name
+                  type:(NSString *)type
+              protocol:(NSString *)protocol
+                domain:(NSString *)domain
+              implType:(NSString *)implType
+               options:(JS::NativeZeroconf::NativeResolveOptions &)options
+               resolve:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject;
+- (void)checkLocalNetworkAccess:(NSString *)type
+                        timeout:(double)timeout
+                        resolve:(RCTPromiseResolveBlock)resolve
+                         reject:(RCTPromiseRejectBlock)reject;
+
+@end
+
+@interface NativeZeroconfSpecBase : NSObject {
+@protected
+facebook::react::EventEmitterCallback _eventEmitterCallback;
+}
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper;
+
+- (void)emitOnStart:(NSDictionary *)value;
+- (void)emitOnStop:(NSDictionary *)value;
+- (void)emitOnFound:(NSDictionary *)value;
+- (void)emitOnRemove:(NSDictionary *)value;
+- (void)emitOnResolved:(NSDictionary *)value;
+- (void)emitOnError:(NSDictionary *)value;
+- (void)emitOnPublished:(NSDictionary *)value;
+- (void)emitOnUnpublished:(NSDictionary *)value;
+@end
+
+namespace facebook::react {
+  /**
+   * ObjC++ class for module 'NativeZeroconf'
+   */
+  class JSI_EXPORT NativeZeroconfSpecJSI : public ObjCTurboModule {
+  public:
+    NativeZeroconfSpecJSI(const ObjCTurboModule::InitParams &params);
+  };
+} // namespace facebook::react
+inline std::optional<double> JS::NativeZeroconf::NativeScanOptions::resolveTimeout() const
+{
+  id const p = _v[@"resolveTimeout"];
+  return RCTBridgingToOptionalDouble(p);
+}
+inline NSString *JS::NativeZeroconf::NativeScanOptions::subtype() const
+{
+  id const p = _v[@"subtype"];
+  return RCTBridgingToOptionalString(p);
+}
+inline NSString *JS::NativeZeroconf::NativeScanOptions::networkInterface() const
+{
+  id const p = _v[@"networkInterface"];
+  return RCTBridgingToOptionalString(p);
+}
+inline std::optional<facebook::react::LazyVector<NSString *>> JS::NativeZeroconf::NativePublishOptions::subtypes() const
+{
+  id const p = _v[@"subtypes"];
+  return RCTBridgingToOptionalVec(p, ^NSString *(id itemValue_0) { return RCTBridgingToString(itemValue_0); });
+}
+inline NSString *JS::NativeZeroconf::NativePublishOptions::networkInterface() const
+{
+  id const p = _v[@"networkInterface"];
+  return RCTBridgingToOptionalString(p);
+}
+inline std::optional<double> JS::NativeZeroconf::NativeResolveOptions::timeout() const
+{
+  id const p = _v[@"timeout"];
+  return RCTBridgingToOptionalDouble(p);
+}
+inline NSString *JS::NativeZeroconf::NativeResolveOptions::networkInterface() const
+{
+  id const p = _v[@"networkInterface"];
+  return RCTBridgingToOptionalString(p);
+}
+NS_ASSUME_NONNULL_END
+#endif // RNZeroconfSpec_H