@dawidzawada/bonjour-zeroconf 1.0.0

package/lib/module/specs/ScanResult.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=ScanResult.js.map

package/lib/module/specs/ScanResult.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/ScanResult.ts"],"mappings":"","ignoreList":[]}

package/lib/module/useIsScanning.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { Scanner } from "./index.js";
+export const useIsScanning = () => {
+  const [scanRunning, setScanRunning] = useState(false);
+  useEffect(() => {
+    const {
+      remove
+    } = Scanner.listenForScanState(scanning => {
+      setScanRunning(scanning);
+    });
+    return () => {
+      remove();
+    };
+  }, []);
+  return scanRunning;
+};
+//# sourceMappingURL=useIsScanning.js.map

package/lib/module/useIsScanning.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useState","Scanner","useIsScanning","scanRunning","setScanRunning","remove","listenForScanState","scanning"],"sourceRoot":"../../src","sources":["useIsScanning.ts"],"mappings":";;AAAA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AAC3C,SAASC,OAAO,QAAQ,YAAS;AAEjC,OAAO,MAAMC,aAAa,GAAGA,CAAA,KAAM;EACjC,MAAM,CAACC,WAAW,EAAEC,cAAc,CAAC,GAAGJ,QAAQ,CAAC,KAAK,CAAC;EAErDD,SAAS,CAAC,MAAM;IACd,MAAM;MAAEM;IAAO,CAAC,GAAGJ,OAAO,CAACK,kBAAkB,CAAEC,QAAQ,IAAK;MAC1DH,cAAc,CAACG,QAAQ,CAAC;IAC1B,CAAC,CAAC;IACF,OAAO,MAAM;MACXF,MAAM,CAAC,CAAC;IACV,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,OAAOF,WAAW;AACpB,CAAC","ignoreList":[]}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,9 @@
+import type { BonjourZeroconf } from './specs/BonjourZeroconf.nitro';
+import { useIsScanning } from './useIsScanning';
+import { type ScanResult } from './specs/ScanResult';
+import { type ScanOptions } from './specs/BonjourZeroconf.nitro';
+import { BonjourFail } from './specs/BonjourFail';
+import { requestLocalNetworkPermission, useLocalNetworkPermission } from './permissions';
+export declare const Scanner: BonjourZeroconf;
+export { useIsScanning, requestLocalNetworkPermission, useLocalNetworkPermission, BonjourFail, type ScanResult, type ScanOptions, };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,EAC1B,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,OAAO,iBACiD,CAAC;AAEtE,OAAO,EACL,aAAa,EACb,6BAA6B,EAC7B,yBAAyB,EACzB,WAAW,EACX,KAAK,UAAU,EACf,KAAK,WAAW,GACjB,CAAC"}

package/lib/typescript/src/permissions.d.ts

@@ -0,0 +1,3 @@
+export declare const requestLocalNetworkPermission: () => Promise<boolean>;
+export declare const useLocalNetworkPermission: () => (boolean | (() => Promise<boolean>))[];
+//# sourceMappingURL=permissions.d.ts.map

package/lib/typescript/src/permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../../src/permissions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,wBAEzC,CAAC;AAEF,eAAO,MAAM,yBAAyB,8CAErC,CAAC"}

package/lib/typescript/src/permissions.ios.d.ts

@@ -0,0 +1,3 @@
+export declare const requestLocalNetworkPermission: () => Promise<boolean>;
+export declare const useLocalNetworkPermission: () => (boolean | (() => Promise<boolean>))[];
+//# sourceMappingURL=permissions.ios.d.ts.map

package/lib/typescript/src/permissions.ios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.ios.d.ts","sourceRoot":"","sources":["../../../src/permissions.ios.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,6BAA6B,wBAEzC,CAAC;AAEF,eAAO,MAAM,yBAAyB,8CAarC,CAAC"}

package/lib/typescript/src/specs/BonjourFail.d.ts

@@ -0,0 +1,6 @@
+export declare enum BonjourFail {
+    RESOLVE_FAILED = 0,
+    EXTRACTION_FAILED = 1,
+    DISCOVERY_FAILED = 2
+}
+//# sourceMappingURL=BonjourFail.d.ts.map

package/lib/typescript/src/specs/BonjourFail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BonjourFail.d.ts","sourceRoot":"","sources":["../../../../src/specs/BonjourFail.ts"],"names":[],"mappings":"AAAA,oBAAY,WAAW;IACrB,cAAc,IAAA;IACd,iBAAiB,IAAA;IACjB,gBAAgB,IAAA;CACjB"}

package/lib/typescript/src/specs/BonjourListener.d.ts

@@ -0,0 +1,4 @@
+export interface BonjourListener {
+    remove: () => void;
+}
+//# sourceMappingURL=BonjourListener.d.ts.map

package/lib/typescript/src/specs/BonjourListener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BonjourListener.d.ts","sourceRoot":"","sources":["../../../../src/specs/BonjourListener.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB"}

package/lib/typescript/src/specs/BonjourZeroconf.nitro.d.ts

@@ -0,0 +1,19 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { BonjourFail } from './BonjourFail';
+import type { BonjourListener } from './BonjourListener';
+import type { ScanResult } from './ScanResult';
+export interface ScanOptions {
+    addressResolveTimeout?: number;
+}
+export interface BonjourZeroconf extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    readonly isScanning: boolean;
+    scan(type: string, domain: string, options?: ScanOptions): void;
+    stop(): void;
+    listenForScanResults(onResult: (results: ScanResult[]) => void): BonjourListener;
+    listenForScanState(onChange: (isScanning: boolean) => void): BonjourListener;
+    listenForScanFail(onFail: (fail: BonjourFail) => void): BonjourListener;
+}
+//# sourceMappingURL=BonjourZeroconf.nitro.d.ts.map

package/lib/typescript/src/specs/BonjourZeroconf.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BonjourZeroconf.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/BonjourZeroconf.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,WAAW;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,eACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAChE,IAAI,IAAI,IAAI,CAAC;IACb,oBAAoB,CAClB,QAAQ,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,GACxC,eAAe,CAAC;IACnB,kBAAkB,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,GAAG,eAAe,CAAC;IAC7E,iBAAiB,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,GAAG,eAAe,CAAC;CACzE"}

package/lib/typescript/src/specs/LocalNetworkPermission.nitro.d.ts

@@ -0,0 +1,9 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { BonjourListener } from './BonjourListener';
+export interface LocalNetworkPermission extends HybridObject<{
+    ios: 'swift';
+}> {
+    requestPermission(): Promise<boolean>;
+    listenForPermission(onChange: (granted: boolean) => void): BonjourListener;
+}
+//# sourceMappingURL=LocalNetworkPermission.nitro.d.ts.map

package/lib/typescript/src/specs/LocalNetworkPermission.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalNetworkPermission.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/LocalNetworkPermission.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,WAAW,sBAAuB,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,CAAC;IAC5E,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IACtC,mBAAmB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,eAAe,CAAC;CAC5E"}

package/lib/typescript/src/specs/ScanResult.d.ts

@@ -0,0 +1,8 @@
+export interface ScanResult {
+    name: string;
+    ipv4?: string;
+    ipv6?: string;
+    hostname?: string;
+    port?: number;
+}
+//# sourceMappingURL=ScanResult.d.ts.map

package/lib/typescript/src/specs/ScanResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScanResult.d.ts","sourceRoot":"","sources":["../../../../src/specs/ScanResult.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/lib/typescript/src/useIsScanning.d.ts

@@ -0,0 +1,2 @@
+export declare const useIsScanning: () => boolean;
+//# sourceMappingURL=useIsScanning.d.ts.map

package/lib/typescript/src/useIsScanning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsScanning.d.ts","sourceRoot":"","sources":["../../../src/useIsScanning.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,eAazB,CAAC"}

package/nitro.json

@@ -0,0 +1,20 @@
+{
+  "cxxNamespace": ["dawidzawada_bonjourzeroconf"],
+  "ios": {
+    "iosModuleName": "BonjourZeroconf"
+  },
+  "android": {
+    "androidNamespace": ["dawidzawada", "bonjourzeroconf"],
+    "androidCxxLibName": "dawidzawada_bonjourzeroconf"
+  },
+  "autolinking": {
+    "BonjourZeroconf": {
+      "swift": "BonjourZeroconf",
+      "kotlin": "BonjourZeroconf"
+    },
+    "LocalNetworkPermission": {
+      "swift": "LocalNetworkPermission"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/c++/JBonjourFail.hpp

@@ -0,0 +1,62 @@
+///
+/// JBonjourFail.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 <fbjni/fbjni.h>
+#include "BonjourFail.hpp"
+
+namespace margelo::nitro::dawidzawada_bonjourzeroconf {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "BonjourFail" and the the Kotlin enum "BonjourFail".
+   */
+  struct JBonjourFail final: public jni::JavaClass<JBonjourFail> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dawidzawada/bonjourzeroconf/BonjourFail;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum BonjourFail.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BonjourFail toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<BonjourFail>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JBonjourFail> fromCpp(BonjourFail value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldRESOLVE_FAILED = clazz->getStaticField<JBonjourFail>("RESOLVE_FAILED");
+      static const auto fieldEXTRACTION_FAILED = clazz->getStaticField<JBonjourFail>("EXTRACTION_FAILED");
+      static const auto fieldDISCOVERY_FAILED = clazz->getStaticField<JBonjourFail>("DISCOVERY_FAILED");
+      
+      switch (value) {
+        case BonjourFail::RESOLVE_FAILED:
+          return clazz->getStaticFieldValue(fieldRESOLVE_FAILED);
+        case BonjourFail::EXTRACTION_FAILED:
+          return clazz->getStaticFieldValue(fieldEXTRACTION_FAILED);
+        case BonjourFail::DISCOVERY_FAILED:
+          return clazz->getStaticFieldValue(fieldDISCOVERY_FAILED);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::dawidzawada_bonjourzeroconf

package/nitrogen/generated/android/c++/JBonjourListener.hpp

@@ -0,0 +1,68 @@
+///
+/// JBonjourListener.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 <fbjni/fbjni.h>
+#include "BonjourListener.hpp"
+
+#include "JFunc_void.hpp"
+#include <functional>
+
+namespace margelo::nitro::dawidzawada_bonjourzeroconf {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BonjourListener" and the the Kotlin data class "BonjourListener".
+   */
+  struct JBonjourListener final: public jni::JavaClass<JBonjourListener> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dawidzawada/bonjourzeroconf/BonjourListener;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BonjourListener by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BonjourListener toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldRemove = clazz->getField<JFunc_void::javaobject>("remove");
+      jni::local_ref<JFunc_void::javaobject> remove = this->getFieldValue(fieldRemove);
+      return BonjourListener(
+        [&]() -> std::function<void()> {
+          if (remove->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(remove);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto removeRef = jni::make_global(remove);
+            return [removeRef]() -> void {
+              return removeRef->invoke();
+            };
+          }
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JBonjourListener::javaobject> fromCpp(const BonjourListener& value) {
+      using JSignature = JBonjourListener(jni::alias_ref<JFunc_void::javaobject>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JFunc_void_cxx::fromCpp(value.remove)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::dawidzawada_bonjourzeroconf

package/nitrogen/generated/android/c++/JFunc_void.hpp

@@ -0,0 +1,74 @@
+///
+/// JFunc_void.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+
+namespace margelo::nitro::dawidzawada_bonjourzeroconf {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dawidzawada/bonjourzeroconf/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dawidzawada/bonjourzeroconf/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::dawidzawada_bonjourzeroconf

package/nitrogen/generated/android/c++/JFunc_void_BonjourFail.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_BonjourFail.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include "BonjourFail.hpp"
+#include <functional>
+#include "JBonjourFail.hpp"
+
+namespace margelo::nitro::dawidzawada_bonjourzeroconf {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(fail: BonjourFail) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_BonjourFail: public jni::JavaClass<JFunc_void_BonjourFail> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dawidzawada/bonjourzeroconf/Func_void_BonjourFail;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_BonjourFail` instance holds through JNI.
+     */
+    void invoke(BonjourFail fail) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JBonjourFail> /* fail */)>("invoke");
+      method(self(), JBonjourFail::fromCpp(fail));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_BonjourFail that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_BonjourFail_cxx final: public jni::HybridClass<JFunc_void_BonjourFail_cxx, JFunc_void_BonjourFail> {
+  public:
+    static jni::local_ref<JFunc_void_BonjourFail::javaobject> fromCpp(const std::function<void(BonjourFail /* fail */)>& func) {
+      return JFunc_void_BonjourFail_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_BonjourFail_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JBonjourFail> fail) {
+      _func(fail->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(BonjourFail /* fail */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dawidzawada/bonjourzeroconf/Func_void_BonjourFail_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_BonjourFail_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_BonjourFail_cxx(const std::function<void(BonjourFail /* fail */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(BonjourFail /* fail */)> _func;
+  };
+
+} // namespace margelo::nitro::dawidzawada_bonjourzeroconf

package/nitrogen/generated/android/c++/JFunc_void_bool.hpp

@@ -0,0 +1,74 @@
+///
+/// JFunc_void_bool.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+
+namespace margelo::nitro::dawidzawada_bonjourzeroconf {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(isScanning: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dawidzawada/bonjourzeroconf/Func_void_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
+     */
+    void invoke(bool isScanning) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* isScanning */)>("invoke");
+      method(self(), isScanning);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
+  public:
+    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* isScanning */)>& func) {
+      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean isScanning) {
+      _func(static_cast<bool>(isScanning));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* isScanning */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dawidzawada/bonjourzeroconf/Func_void_bool_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_cxx(const std::function<void(bool /* isScanning */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* isScanning */)> _func;
+  };
+
+} // namespace margelo::nitro::dawidzawada_bonjourzeroconf

package/nitrogen/generated/android/c++/JFunc_void_std__vector_ScanResult_.hpp

@@ -0,0 +1,97 @@
+///
+/// JFunc_void_std__vector_ScanResult_.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 <fbjni/fbjni.h>
+#include <functional>
+
+#include "ScanResult.hpp"
+#include <vector>
+#include <functional>
+#include "JScanResult.hpp"
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::dawidzawada_bonjourzeroconf {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(results: Array<ScanResult>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_ScanResult_: public jni::JavaClass<JFunc_void_std__vector_ScanResult_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dawidzawada/bonjourzeroconf/Func_void_std__vector_ScanResult_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_ScanResult_` instance holds through JNI.
+     */
+    void invoke(const std::vector<ScanResult>& results) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JScanResult>> /* results */)>("invoke");
+      method(self(), [&]() {
+        size_t __size = results.size();
+        jni::local_ref<jni::JArrayClass<JScanResult>> __array = jni::JArrayClass<JScanResult>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = results[__i];
+          auto __elementJni = JScanResult::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }());
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_ScanResult_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_std__vector_ScanResult__cxx final: public jni::HybridClass<JFunc_void_std__vector_ScanResult__cxx, JFunc_void_std__vector_ScanResult_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_ScanResult_::javaobject> fromCpp(const std::function<void(const std::vector<ScanResult>& /* results */)>& func) {
+      return JFunc_void_std__vector_ScanResult__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_ScanResult__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JScanResult>> results) {
+      _func([&]() {
+              size_t __size = results->size();
+              std::vector<ScanResult> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = results->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<ScanResult>& /* results */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dawidzawada/bonjourzeroconf/Func_void_std__vector_ScanResult__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_ScanResult__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_ScanResult__cxx(const std::function<void(const std::vector<ScanResult>& /* results */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<ScanResult>& /* results */)> _func;
+  };
+
+} // namespace margelo::nitro::dawidzawada_bonjourzeroconf