@minip2p/react-native 0.7.2 → 0.7.4

package/lib/module/generated/minip2p_ffi_core.js

@@ -0,0 +1,3342 @@
+"use strict";
+
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+import nativeModule from "./minip2p_ffi_core-ffi.js";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiEnum, UniffiError, UniffiInternalError, UniffiRustCaller, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiTypeNameSymbol } from "@ubjs/core";
+const uniffiCaller = new UniffiRustCaller(() => ({
+  code: 0
+}));
+const uniffiIsDebug =
+// @ts-ignore -- The process global might not be defined
+typeof process !== "object" ||
+// @ts-ignore -- The process global might not be defined
+process?.env?.NODE_ENV !== "production" || false;
+
+// Public interface members begin here.
+
+// Hermes (React Native ≥ 0.74) ships TextEncoder and encodeInto, but not
+// TextDecoder. For single-string decode (bytesToString), we polyfill via the
+// C++ string_from_buffer helper using a duck-typed object matching the
+// standard TextDecoder.decode signature. Once Hermes ships a real
+// TextDecoder, the `typeof` check will pick it up automatically.
+//
+// For array-of-strings decode (readStringFromBuffer), we keep a dedicated C++
+// helper: the polyfill path (new Uint8Array view + decode) measured ~40%
+// slower on getStringArray benchmarks than a direct (buf, offset, length)
+// call, due to the per-read view allocation and extra property lookups in
+// string_from_buffer.
+const stringConverter = (() => {
+  const encoder = new TextEncoder();
+  const decoder = typeof TextDecoder !== "undefined" ? new TextDecoder() : {
+    decode: bytes => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_from_buffer(bytes, undefined)
+  };
+  return {
+    // Single-string lower() uses the C++ helper — TextEncoder.encode
+    // measured ~43% slower on takeString benchmarks.
+    stringToBytes: s => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_buffer(s, undefined),
+    bytesToString: ab => decoder.decode(ab),
+    // Direct C++ call — bypasses uniffiCaller.rustCall() overhead.
+    // Matters for N-element arrays.
+    stringByteLength: s => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(s, undefined),
+    // Encode directly into the RustBuffer backing store via
+    // TextEncoder.encodeInto — zero intermediate allocation. Replaces
+    // the old C++ write_string_into_buffer helper.
+    writeStringIntoBuffer: (s, buf, offset) => {
+      const view = new Uint8Array(buf.arrayBuffer, offset, buf.arrayBuffer.byteLength - offset);
+      return encoder.encodeInto(s, view).written;
+    },
+    // Dedicated C++ helper — avoids per-read Uint8Array allocation and
+    // the double property-lookup in string_from_buffer.
+    readStringFromBuffer: (buf, offset, length) => nativeModule().ubrn_uniffi_internal_fn_func_ffi__read_string_from_buffer(buf, offset, length)
+  };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+/**
+ * State snapshot of the transport connection selected for a peer.
+ */
+
+/**
+ * Generated factory for {@link ConnectionInfo} record objects.
+ */
+export const ConnectionInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeConnectionInfo = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        connId: FfiConverterUInt64.readFromCursor(c),
+        remoteAddr: FfiConverterOptionalString.readFromCursor(c),
+        readyProtocols: FfiConverterOptionalSequenceString.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterUInt64.writeIntoCursor(value.connId, c);
+      FfiConverterOptionalString.writeIntoCursor(value.remoteAddr, c);
+      FfiConverterOptionalSequenceString.writeIntoCursor(value.readyProtocols, c);
+    }
+    allocationSize(value) {
+      return FfiConverterUInt64.allocationSize(value.connId) + FfiConverterOptionalString.allocationSize(value.remoteAddr) + FfiConverterOptionalSequenceString.allocationSize(value.readyProtocols);
+    }
+  }
+  ;
+  return new FFIConverter();
+})();
+
+/**
+ * Signed-discovery configuration.
+ */
+
+/**
+ * Generated factory for {@link DiscoveryOptions} record objects.
+ */
+export const DiscoveryOptions = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeDiscoveryOptions = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        topic: FfiConverterString.readFromCursor(c),
+        beaconIntervalMs: FfiConverterUInt64.readFromCursor(c),
+        peerTtlMs: FfiConverterUInt64.readFromCursor(c),
+        autoDial: FfiConverterBool.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterString.writeIntoCursor(value.topic, c);
+      FfiConverterUInt64.writeIntoCursor(value.beaconIntervalMs, c);
+      FfiConverterUInt64.writeIntoCursor(value.peerTtlMs, c);
+      FfiConverterBool.writeIntoCursor(value.autoDial, c);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.topic) + FfiConverterUInt64.allocationSize(value.beaconIntervalMs) + FfiConverterUInt64.allocationSize(value.peerTtlMs) + FfiConverterBool.allocationSize(value.autoDial);
+    }
+  }
+  ;
+  return new FFIConverter();
+})();
+
+/**
+ * Local-link mDNS discovery configuration.
+ */
+
+/**
+ * Generated factory for {@link MdnsOptions} record objects.
+ */
+export const MdnsOptions = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeMdnsOptions = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        enableIpv6: FfiConverterBool.readFromCursor(c),
+        ttlMs: FfiConverterUInt64.readFromCursor(c),
+        queryIntervalMs: FfiConverterUInt64.readFromCursor(c),
+        maxPacketBytes: FfiConverterUInt32.readFromCursor(c),
+        maxAnnouncedAddrs: FfiConverterUInt32.readFromCursor(c),
+        interfaceRefreshMs: FfiConverterUInt64.readFromCursor(c),
+        socketPollIntervalMs: FfiConverterUInt64.readFromCursor(c),
+        autoDial: FfiConverterBool.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterBool.writeIntoCursor(value.enableIpv6, c);
+      FfiConverterUInt64.writeIntoCursor(value.ttlMs, c);
+      FfiConverterUInt64.writeIntoCursor(value.queryIntervalMs, c);
+      FfiConverterUInt32.writeIntoCursor(value.maxPacketBytes, c);
+      FfiConverterUInt32.writeIntoCursor(value.maxAnnouncedAddrs, c);
+      FfiConverterUInt64.writeIntoCursor(value.interfaceRefreshMs, c);
+      FfiConverterUInt64.writeIntoCursor(value.socketPollIntervalMs, c);
+      FfiConverterBool.writeIntoCursor(value.autoDial, c);
+    }
+    allocationSize(value) {
+      return FfiConverterBool.allocationSize(value.enableIpv6) + FfiConverterUInt64.allocationSize(value.ttlMs) + FfiConverterUInt64.allocationSize(value.queryIntervalMs) + FfiConverterUInt32.allocationSize(value.maxPacketBytes) + FfiConverterUInt32.allocationSize(value.maxAnnouncedAddrs) + FfiConverterUInt64.allocationSize(value.interfaceRefreshMs) + FfiConverterUInt64.allocationSize(value.socketPollIntervalMs) + FfiConverterBool.allocationSize(value.autoDial);
+    }
+  }
+  ;
+  return new FFIConverter();
+})();
+
+/**
+ * Configuration used to construct an FFI endpoint.
+ */
+
+/**
+ * Generated factory for {@link EndpointConfig} record objects.
+ */
+export const EndpointConfig = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeEndpointConfig = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        agentVersion: FfiConverterOptionalString.readFromCursor(c),
+        relays: FfiConverterSequenceString.readFromCursor(c),
+        autonatServers: FfiConverterSequenceString.readFromCursor(c),
+        listen: FfiConverterOptionalSequenceString.readFromCursor(c),
+        forceRelay: FfiConverterBool.readFromCursor(c),
+        allowUnsigned: FfiConverterBool.readFromCursor(c),
+        protocols: FfiConverterSequenceString.readFromCursor(c),
+        discovery: FfiConverterOptionalTypeDiscoveryOptions.readFromCursor(c),
+        mdns: FfiConverterOptionalTypeMdnsOptions.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterOptionalString.writeIntoCursor(value.agentVersion, c);
+      FfiConverterSequenceString.writeIntoCursor(value.relays, c);
+      FfiConverterSequenceString.writeIntoCursor(value.autonatServers, c);
+      FfiConverterOptionalSequenceString.writeIntoCursor(value.listen, c);
+      FfiConverterBool.writeIntoCursor(value.forceRelay, c);
+      FfiConverterBool.writeIntoCursor(value.allowUnsigned, c);
+      FfiConverterSequenceString.writeIntoCursor(value.protocols, c);
+      FfiConverterOptionalTypeDiscoveryOptions.writeIntoCursor(value.discovery, c);
+      FfiConverterOptionalTypeMdnsOptions.writeIntoCursor(value.mdns, c);
+    }
+    allocationSize(value) {
+      return FfiConverterOptionalString.allocationSize(value.agentVersion) + FfiConverterSequenceString.allocationSize(value.relays) + FfiConverterSequenceString.allocationSize(value.autonatServers) + FfiConverterOptionalSequenceString.allocationSize(value.listen) + FfiConverterBool.allocationSize(value.forceRelay) + FfiConverterBool.allocationSize(value.allowUnsigned) + FfiConverterSequenceString.allocationSize(value.protocols) + FfiConverterOptionalTypeDiscoveryOptions.allocationSize(value.discovery) + FfiConverterOptionalTypeMdnsOptions.allocationSize(value.mdns);
+    }
+  }
+  ;
+  return new FFIConverter();
+})();
+
+/**
+ * Foreign-friendly snapshot of a peer's Identify message.
+ */
+
+/**
+ * Generated factory for {@link IdentifyInfo} record objects.
+ */
+export const IdentifyInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeIdentifyInfo = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        publicKey: FfiConverterOptionalBytes.readFromCursor(c),
+        listenAddrs: FfiConverterSequenceString.readFromCursor(c),
+        protocols: FfiConverterSequenceString.readFromCursor(c),
+        observedAddr: FfiConverterOptionalString.readFromCursor(c),
+        protocolVersion: FfiConverterOptionalString.readFromCursor(c),
+        agentVersion: FfiConverterOptionalString.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterOptionalBytes.writeIntoCursor(value.publicKey, c);
+      FfiConverterSequenceString.writeIntoCursor(value.listenAddrs, c);
+      FfiConverterSequenceString.writeIntoCursor(value.protocols, c);
+      FfiConverterOptionalString.writeIntoCursor(value.observedAddr, c);
+      FfiConverterOptionalString.writeIntoCursor(value.protocolVersion, c);
+      FfiConverterOptionalString.writeIntoCursor(value.agentVersion, c);
+    }
+    allocationSize(value) {
+      return FfiConverterOptionalBytes.allocationSize(value.publicKey) + FfiConverterSequenceString.allocationSize(value.listenAddrs) + FfiConverterSequenceString.allocationSize(value.protocols) + FfiConverterOptionalString.allocationSize(value.observedAddr) + FfiConverterOptionalString.allocationSize(value.protocolVersion) + FfiConverterOptionalString.allocationSize(value.agentVersion);
+    }
+  }
+  ;
+  return new FFIConverter();
+})();
+
+/**
+ * One peer in the shared discovery address book.
+ */
+
+/**
+ * Generated factory for {@link KnownPeerInfo} record objects.
+ */
+export const KnownPeerInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeKnownPeerInfo = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        peerId: FfiConverterString.readFromCursor(c),
+        addrs: FfiConverterSequenceString.readFromCursor(c),
+        beaconAddrs: FfiConverterSequenceString.readFromCursor(c),
+        mdnsAddrs: FfiConverterSequenceString.readFromCursor(c),
+        beaconLastSeenAgeMs: FfiConverterOptionalUInt64.readFromCursor(c),
+        mdnsLastSeenAgeMs: FfiConverterOptionalUInt64.readFromCursor(c),
+        connected: FfiConverterBool.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterString.writeIntoCursor(value.peerId, c);
+      FfiConverterSequenceString.writeIntoCursor(value.addrs, c);
+      FfiConverterSequenceString.writeIntoCursor(value.beaconAddrs, c);
+      FfiConverterSequenceString.writeIntoCursor(value.mdnsAddrs, c);
+      FfiConverterOptionalUInt64.writeIntoCursor(value.beaconLastSeenAgeMs, c);
+      FfiConverterOptionalUInt64.writeIntoCursor(value.mdnsLastSeenAgeMs, c);
+      FfiConverterBool.writeIntoCursor(value.connected, c);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.peerId) + FfiConverterSequenceString.allocationSize(value.addrs) + FfiConverterSequenceString.allocationSize(value.beaconAddrs) + FfiConverterSequenceString.allocationSize(value.mdnsAddrs) + FfiConverterOptionalUInt64.allocationSize(value.beaconLastSeenAgeMs) + FfiConverterOptionalUInt64.allocationSize(value.mdnsLastSeenAgeMs) + FfiConverterBool.allocationSize(value.connected);
+    }
+  }
+  ;
+  return new FFIConverter();
+})();
+
+/**
+ * Full identity allocated for an outbound application stream.
+ */
+
+/**
+ * Generated factory for {@link OpenStreamResult} record objects.
+ */
+export const OpenStreamResult = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeOpenStreamResult = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        connId: FfiConverterUInt64.readFromCursor(c),
+        streamId: FfiConverterUInt64.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterUInt64.writeIntoCursor(value.connId, c);
+      FfiConverterUInt64.writeIntoCursor(value.streamId, c);
+    }
+    allocationSize(value) {
+      return FfiConverterUInt64.allocationSize(value.connId) + FfiConverterUInt64.allocationSize(value.streamId);
+    }
+  }
+  ;
+  return new FFIConverter();
+})();
+
+/**
+ * Snapshot of the active inbound relay reservation.
+ */
+
+/**
+ * Generated factory for {@link RelayReservationInfo} record objects.
+ */
+export const RelayReservationInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeRelayReservationInfo = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        relayPeerId: FfiConverterString.readFromCursor(c),
+        expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterString.writeIntoCursor(value.relayPeerId, c);
+      FfiConverterOptionalUInt64.writeIntoCursor(value.expiresUnixSecs, c);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.relayPeerId) + FfiConverterOptionalUInt64.allocationSize(value.expiresUnixSecs);
+    }
+  }
+  ;
+  return new FFIConverter();
+})();
+
+// Enum: ConnectTarget
+export let ConnectTarget_Tags = /*#__PURE__*/function (ConnectTarget_Tags) {
+  ConnectTarget_Tags["Peer"] = "Peer";
+  ConnectTarget_Tags["Addresses"] = "Addresses";
+  return ConnectTarget_Tags;
+}({});
+/**
+ * What a foreign runtime supplies to start one Connection attempt.
+ *
+ * Validation for every form lives in this module, once; binding shells only
+ * adapt the shape to their toolchain.
+ */
+export const ConnectTarget = (() => {
+  /**
+   * Peer ID only: the endpoint applies its discovery-book and relay
+   * policy.
+   */
+  class Peer_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "ConnectTarget";
+    tag = ConnectTarget_Tags.Peer;
+    constructor(inner) {
+      super("ConnectTarget", "Peer");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Peer_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === ConnectTarget_Tags.Peer;
+    }
+  }
+  /**
+   * One or more complete direct peer addresses that all name the same
+   * peer. One address is the single-address form.
+   */
+  class Addresses_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "ConnectTarget";
+    tag = ConnectTarget_Tags.Addresses;
+    constructor(inner) {
+      super("ConnectTarget", "Addresses");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Addresses_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === ConnectTarget_Tags.Addresses;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "ConnectTarget";
+  }
+  return Object.freeze({
+    instanceOf,
+    Peer: Peer_,
+    Addresses: Addresses_
+  });
+})();
+/**
+ * What a foreign runtime supplies to start one Connection attempt.
+ *
+ * Validation for every form lives in this module, once; binding shells only
+ * adapt the shape to their toolchain.
+ */
+
+// FfiConverter for enum ConnectTarget
+const FfiConverterTypeConnectTarget = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return new ConnectTarget.Peer({
+            peerId: FfiConverterString.readFromCursor(c)
+          });
+        case 2:
+          return new ConnectTarget.Addresses({
+            addresses: FfiConverterSequenceString.readFromCursor(c)
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value.tag) {
+        case ConnectTarget_Tags.Peer:
+          {
+            c.writeI32(1);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            return;
+          }
+        case ConnectTarget_Tags.Addresses:
+          {
+            c.writeI32(2);
+            const inner = value.inner;
+            FfiConverterSequenceString.writeIntoCursor(inner.addresses, c);
+            return;
+          }
+        default:
+          // Throwing from here means that ConnectTarget_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case ConnectTarget_Tags.Peer:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            return size;
+          }
+        case ConnectTarget_Tags.Addresses:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterSequenceString.allocationSize(inner.addresses);
+            return size;
+          }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Source that contributed a discovery observation.
+ */
+export let DiscoverySource = /*#__PURE__*/function (DiscoverySource) {
+  /**
+   * Public-key-authenticated signed beacon.
+   */
+  DiscoverySource[DiscoverySource["SignedBeacon"] = 0] = "SignedBeacon";
+  /**
+   * Unauthenticated local-link mDNS observation.
+   */
+  DiscoverySource[DiscoverySource["Mdns"] = 1] = "Mdns";
+  return DiscoverySource;
+}({});
+const FfiConverterTypeDiscoverySource = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return DiscoverySource.SignedBeacon;
+        case 2:
+          return DiscoverySource.Mdns;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case DiscoverySource.SignedBeacon:
+          return c.writeI32(1);
+        case DiscoverySource.Mdns:
+          return c.writeI32(2);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Category of a fatal background-driver failure.
+ */
+export let DriverFailureKind = /*#__PURE__*/function (DriverFailureKind) {
+  /**
+   * The transport driver failed.
+   */
+  DriverFailureKind[DriverFailureKind["Transport"] = 0] = "Transport";
+  /**
+   * The swarm driver failed.
+   */
+  DriverFailureKind[DriverFailureKind["Swarm"] = 1] = "Swarm";
+  /**
+   * An internal driver invariant failed.
+   */
+  DriverFailureKind[DriverFailureKind["Invariant"] = 2] = "Invariant";
+  /**
+   * The background pump panicked.
+   */
+  DriverFailureKind[DriverFailureKind["Panic"] = 3] = "Panic";
+  return DriverFailureKind;
+}({});
+const FfiConverterTypeDriverFailureKind = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return DriverFailureKind.Transport;
+        case 2:
+          return DriverFailureKind.Swarm;
+        case 3:
+          return DriverFailureKind.Invariant;
+        case 4:
+          return DriverFailureKind.Panic;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case DriverFailureKind.Transport:
+          return c.writeI32(1);
+        case DriverFailureKind.Swarm:
+          return c.writeI32(2);
+        case DriverFailureKind.Invariant:
+          return c.writeI32(3);
+        case DriverFailureKind.Panic:
+          return c.writeI32(4);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Category of a non-fatal endpoint runtime error.
+ */
+export let EndpointErrorKind = /*#__PURE__*/function (EndpointErrorKind) {
+  /**
+   * Underlying transport operation failed.
+   */
+  EndpointErrorKind[EndpointErrorKind["Transport"] = 0] = "Transport";
+  /**
+   * Multistream negotiation failed.
+   */
+  EndpointErrorKind[EndpointErrorKind["Multistream"] = 1] = "Multistream";
+  /**
+   * Identify protocol failed.
+   */
+  EndpointErrorKind[EndpointErrorKind["Identify"] = 2] = "Identify";
+  /**
+   * Ping protocol failed.
+   */
+  EndpointErrorKind[EndpointErrorKind["Ping"] = 3] = "Ping";
+  /**
+   * Identify stream setup was rejected.
+   */
+  EndpointErrorKind[EndpointErrorKind["IdentifyStreamRejected"] = 4] = "IdentifyStreamRejected";
+  /**
+   * Outbound stream opening failed.
+   */
+  EndpointErrorKind[EndpointErrorKind["OpenStreamFailed"] = 5] = "OpenStreamFailed";
+  /**
+   * The remote does not support a requested protocol.
+   */
+  EndpointErrorKind[EndpointErrorKind["UnsupportedProtocol"] = 6] = "UnsupportedProtocol";
+  /**
+   * The swarm driver contract failed.
+   */
+  EndpointErrorKind[EndpointErrorKind["Driver"] = 7] = "Driver";
+  return EndpointErrorKind;
+}({});
+const FfiConverterTypeEndpointErrorKind = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return EndpointErrorKind.Transport;
+        case 2:
+          return EndpointErrorKind.Multistream;
+        case 3:
+          return EndpointErrorKind.Identify;
+        case 4:
+          return EndpointErrorKind.Ping;
+        case 5:
+          return EndpointErrorKind.IdentifyStreamRejected;
+        case 6:
+          return EndpointErrorKind.OpenStreamFailed;
+        case 7:
+          return EndpointErrorKind.UnsupportedProtocol;
+        case 8:
+          return EndpointErrorKind.Driver;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case EndpointErrorKind.Transport:
+          return c.writeI32(1);
+        case EndpointErrorKind.Multistream:
+          return c.writeI32(2);
+        case EndpointErrorKind.Identify:
+          return c.writeI32(3);
+        case EndpointErrorKind.Ping:
+          return c.writeI32(4);
+        case EndpointErrorKind.IdentifyStreamRejected:
+          return c.writeI32(5);
+        case EndpointErrorKind.OpenStreamFailed:
+          return c.writeI32(6);
+        case EndpointErrorKind.UnsupportedProtocol:
+          return c.writeI32(7);
+        case EndpointErrorKind.Driver:
+          return c.writeI32(8);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Error type: FfiError
+export let FfiError_Tags = /*#__PURE__*/function (FfiError_Tags) {
+  FfiError_Tags["AlreadyStarted"] = "AlreadyStarted";
+  FfiError_Tags["Stopped"] = "Stopped";
+  FfiError_Tags["InvalidConfig"] = "InvalidConfig";
+  FfiError_Tags["InvalidKey"] = "InvalidKey";
+  FfiError_Tags["InvalidPeerId"] = "InvalidPeerId";
+  FfiError_Tags["InvalidAddress"] = "InvalidAddress";
+  FfiError_Tags["InvalidTopic"] = "InvalidTopic";
+  FfiError_Tags["NotPermitted"] = "NotPermitted";
+  FfiError_Tags["Backpressure"] = "Backpressure";
+  FfiError_Tags["MessageTooLarge"] = "MessageTooLarge";
+  FfiError_Tags["Transport"] = "Transport";
+  FfiError_Tags["InvalidState"] = "InvalidState";
+  FfiError_Tags["Internal"] = "Internal";
+  return FfiError_Tags;
+}({});
+/**
+ * An error returned by a synchronous FFI operation.
+ */
+export const FfiError = (() => {
+  /**
+   * The endpoint's background driver was already started.
+   */
+  class AlreadyStarted_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.AlreadyStarted;
+    constructor() {
+      super("FfiError", "AlreadyStarted");
+    }
+    static new() {
+      return new AlreadyStarted_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.AlreadyStarted;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  /**
+   * The endpoint has stopped and cannot be restarted.
+   */
+  class Stopped_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.Stopped;
+    constructor() {
+      super("FfiError", "Stopped");
+    }
+    static new() {
+      return new Stopped_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.Stopped;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  /**
+   * Endpoint configuration was internally inconsistent.
+   */
+  class InvalidConfig_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.InvalidConfig;
+    constructor(inner) {
+      super("FfiError", "InvalidConfig");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidConfig_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.InvalidConfig;
+    }
+    static hasInner(obj) {
+      return InvalidConfig_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  /**
+   * Secret key material was not exactly 32 bytes.
+   */
+  class InvalidKey_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.InvalidKey;
+    constructor(inner) {
+      super("FfiError", "InvalidKey");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidKey_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.InvalidKey;
+    }
+    static hasInner(obj) {
+      return InvalidKey_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  /**
+   * A peer ID could not be parsed.
+   */
+  class InvalidPeerId_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.InvalidPeerId;
+    constructor(inner) {
+      super("FfiError", "InvalidPeerId");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidPeerId_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.InvalidPeerId;
+    }
+    static hasInner(obj) {
+      return InvalidPeerId_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  /**
+   * A multiaddress or peer address could not be parsed.
+   */
+  class InvalidAddress_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.InvalidAddress;
+    constructor(inner) {
+      super("FfiError", "InvalidAddress");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidAddress_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.InvalidAddress;
+    }
+    static hasInner(obj) {
+      return InvalidAddress_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  /**
+   * A pubsub topic failed validation.
+   */
+  class InvalidTopic_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.InvalidTopic;
+    constructor(inner) {
+      super("FfiError", "InvalidTopic");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidTopic_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.InvalidTopic;
+    }
+    static hasInner(obj) {
+      return InvalidTopic_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  /**
+   * The operation is valid but reserved by another endpoint subsystem.
+   */
+  class NotPermitted_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.NotPermitted;
+    constructor(inner) {
+      super("FfiError", "NotPermitted");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new NotPermitted_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.NotPermitted;
+    }
+    static hasInner(obj) {
+      return NotPermitted_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  /**
+   * A bounded outbound queue is full.
+   */
+  class Backpressure_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.Backpressure;
+    constructor() {
+      super("FfiError", "Backpressure");
+    }
+    static new() {
+      return new Backpressure_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.Backpressure;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  /**
+   * A pubsub message exceeds the protocol limit.
+   */
+  class MessageTooLarge_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.MessageTooLarge;
+    constructor() {
+      super("FfiError", "MessageTooLarge");
+    }
+    static new() {
+      return new MessageTooLarge_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.MessageTooLarge;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
+  /**
+   * A synchronous transport operation failed.
+   */
+  class Transport_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.Transport;
+    constructor(inner) {
+      super("FfiError", "Transport");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Transport_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.Transport;
+    }
+    static hasInner(obj) {
+      return Transport_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  /**
+   * The operation is unavailable in the endpoint's current lifecycle state.
+   */
+  class InvalidState_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.InvalidState;
+    constructor(inner) {
+      super("FfiError", "InvalidState");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidState_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.InvalidState;
+    }
+    static hasInner(obj) {
+      return InvalidState_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  /**
+   * An internal invariant or unexpected construction path failed.
+   */
+  class Internal_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "FfiError";
+    tag = FfiError_Tags.Internal;
+    constructor(inner) {
+      super("FfiError", "Internal");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Internal_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === FfiError_Tags.Internal;
+    }
+    static hasInner(obj) {
+      return Internal_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "FfiError";
+  }
+  return Object.freeze({
+    instanceOf,
+    AlreadyStarted: AlreadyStarted_,
+    Stopped: Stopped_,
+    InvalidConfig: InvalidConfig_,
+    InvalidKey: InvalidKey_,
+    InvalidPeerId: InvalidPeerId_,
+    InvalidAddress: InvalidAddress_,
+    InvalidTopic: InvalidTopic_,
+    NotPermitted: NotPermitted_,
+    Backpressure: Backpressure_,
+    MessageTooLarge: MessageTooLarge_,
+    Transport: Transport_,
+    InvalidState: InvalidState_,
+    Internal: Internal_
+  });
+})();
+/**
+ * An error returned by a synchronous FFI operation.
+ */
+
+// FfiConverter for enum FfiError
+const FfiConverterTypeFfiError = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return new FfiError.AlreadyStarted();
+        case 2:
+          return new FfiError.Stopped();
+        case 3:
+          return new FfiError.InvalidConfig({
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 4:
+          return new FfiError.InvalidKey({
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 5:
+          return new FfiError.InvalidPeerId({
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 6:
+          return new FfiError.InvalidAddress({
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 7:
+          return new FfiError.InvalidTopic({
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 8:
+          return new FfiError.NotPermitted({
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 9:
+          return new FfiError.Backpressure();
+        case 10:
+          return new FfiError.MessageTooLarge();
+        case 11:
+          return new FfiError.Transport({
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 12:
+          return new FfiError.InvalidState({
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 13:
+          return new FfiError.Internal({
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value.tag) {
+        case FfiError_Tags.AlreadyStarted:
+          {
+            c.writeI32(1);
+            return;
+          }
+        case FfiError_Tags.Stopped:
+          {
+            c.writeI32(2);
+            return;
+          }
+        case FfiError_Tags.InvalidConfig:
+          {
+            c.writeI32(3);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case FfiError_Tags.InvalidKey:
+          {
+            c.writeI32(4);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case FfiError_Tags.InvalidPeerId:
+          {
+            c.writeI32(5);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case FfiError_Tags.InvalidAddress:
+          {
+            c.writeI32(6);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case FfiError_Tags.InvalidTopic:
+          {
+            c.writeI32(7);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case FfiError_Tags.NotPermitted:
+          {
+            c.writeI32(8);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case FfiError_Tags.Backpressure:
+          {
+            c.writeI32(9);
+            return;
+          }
+        case FfiError_Tags.MessageTooLarge:
+          {
+            c.writeI32(10);
+            return;
+          }
+        case FfiError_Tags.Transport:
+          {
+            c.writeI32(11);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case FfiError_Tags.InvalidState:
+          {
+            c.writeI32(12);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case FfiError_Tags.Internal:
+          {
+            c.writeI32(13);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        default:
+          // Throwing from here means that FfiError_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case FfiError_Tags.AlreadyStarted:
+          {
+            return 4;
+          }
+        case FfiError_Tags.Stopped:
+          {
+            return 4;
+          }
+        case FfiError_Tags.InvalidConfig:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case FfiError_Tags.InvalidKey:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case FfiError_Tags.InvalidPeerId:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case FfiError_Tags.InvalidAddress:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case FfiError_Tags.InvalidTopic:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case FfiError_Tags.NotPermitted:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case FfiError_Tags.Backpressure:
+          {
+            return 4;
+          }
+        case FfiError_Tags.MessageTooLarge:
+          {
+            return 4;
+          }
+        case FfiError_Tags.Transport:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case FfiError_Tags.InvalidState:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case FfiError_Tags.Internal:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Category of a failed NAT connection attempt.
+ */
+export let NatErrorKind = /*#__PURE__*/function (NatErrorKind) {
+  /**
+   * No usable direct or relayed path exists.
+   */
+  NatErrorKind[NatErrorKind["NoPathAvailable"] = 0] = "NoPathAvailable";
+  /**
+   * The connection attempt timed out.
+   */
+  NatErrorKind[NatErrorKind["Timeout"] = 1] = "Timeout";
+  /**
+   * A transport dial failed.
+   */
+  NatErrorKind[NatErrorKind["DialFailed"] = 2] = "DialFailed";
+  /**
+   * A traversal protocol exchange failed.
+   */
+  NatErrorKind[NatErrorKind["Protocol"] = 3] = "Protocol";
+  /**
+   * A relay refused the circuit.
+   */
+  NatErrorKind[NatErrorKind["RelayRefused"] = 4] = "RelayRefused";
+  return NatErrorKind;
+}({});
+const FfiConverterTypeNatErrorKind = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return NatErrorKind.NoPathAvailable;
+        case 2:
+          return NatErrorKind.Timeout;
+        case 3:
+          return NatErrorKind.DialFailed;
+        case 4:
+          return NatErrorKind.Protocol;
+        case 5:
+          return NatErrorKind.RelayRefused;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case NatErrorKind.NoPathAvailable:
+          return c.writeI32(1);
+        case NatErrorKind.Timeout:
+          return c.writeI32(2);
+        case NatErrorKind.DialFailed:
+          return c.writeI32(3);
+        case NatErrorKind.Protocol:
+          return c.writeI32(4);
+        case NatErrorKind.RelayRefused:
+          return c.writeI32(5);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Coarse local reachability state.
+ */
+export let Reachability = /*#__PURE__*/function (Reachability) {
+  /**
+   * Not enough evidence is available.
+   */
+  Reachability[Reachability["Unknown"] = 0] = "Unknown";
+  /**
+   * The endpoint is directly reachable.
+   */
+  Reachability[Reachability["Public"] = 1] = "Public";
+  /**
+   * The endpoint needs traversal or relay assistance.
+   */
+  Reachability[Reachability["Private"] = 2] = "Private";
+  return Reachability;
+}({});
+const FfiConverterTypeReachability = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return Reachability.Unknown;
+        case 2:
+          return Reachability.Public;
+        case 3:
+          return Reachability.Private;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case Reachability.Unknown:
+          return c.writeI32(1);
+        case Reachability.Public:
+          return c.writeI32(2);
+        case Reachability.Private:
+          return c.writeI32(3);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Enum: PathKind
+export let PathKind_Tags = /*#__PURE__*/function (PathKind_Tags) {
+  PathKind_Tags["DirectDialed"] = "DirectDialed";
+  PathKind_Tags["DirectPunched"] = "DirectPunched";
+  PathKind_Tags["Relayed"] = "Relayed";
+  return PathKind_Tags;
+}({});
+/**
+ * Kind of usable connection path.
+ */
+export const PathKind = (() => {
+  /**
+   * A known address was dialed directly.
+   */
+  class DirectDialed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "PathKind";
+    tag = PathKind_Tags.DirectDialed;
+    constructor() {
+      super("PathKind", "DirectDialed");
+    }
+    static new() {
+      return new DirectDialed_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === PathKind_Tags.DirectDialed;
+    }
+  }
+  /**
+   * A direct path was established by hole punching.
+   */
+  class DirectPunched_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "PathKind";
+    tag = PathKind_Tags.DirectPunched;
+    constructor() {
+      super("PathKind", "DirectPunched");
+    }
+    static new() {
+      return new DirectPunched_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === PathKind_Tags.DirectPunched;
+    }
+  }
+  /**
+   * Traffic is carried through a relay.
+   */
+  class Relayed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "PathKind";
+    tag = PathKind_Tags.Relayed;
+    constructor(inner) {
+      super("PathKind", "Relayed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Relayed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === PathKind_Tags.Relayed;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "PathKind";
+  }
+  return Object.freeze({
+    instanceOf,
+    DirectDialed: DirectDialed_,
+    DirectPunched: DirectPunched_,
+    Relayed: Relayed_
+  });
+})();
+/**
+ * Kind of usable connection path.
+ */
+
+// FfiConverter for enum PathKind
+const FfiConverterTypePathKind = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return new PathKind.DirectDialed();
+        case 2:
+          return new PathKind.DirectPunched();
+        case 3:
+          return new PathKind.Relayed({
+            relayPeerId: FfiConverterString.readFromCursor(c)
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value.tag) {
+        case PathKind_Tags.DirectDialed:
+          {
+            c.writeI32(1);
+            return;
+          }
+        case PathKind_Tags.DirectPunched:
+          {
+            c.writeI32(2);
+            return;
+          }
+        case PathKind_Tags.Relayed:
+          {
+            c.writeI32(3);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
+            return;
+          }
+        default:
+          // Throwing from here means that PathKind_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case PathKind_Tags.DirectDialed:
+          {
+            return 4;
+          }
+        case PathKind_Tags.DirectPunched:
+          {
+            return 4;
+          }
+        case PathKind_Tags.Relayed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.relayPeerId);
+            return size;
+          }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Enum: P2pEvent
+export let P2pEvent_Tags = /*#__PURE__*/function (P2pEvent_Tags) {
+  P2pEvent_Tags["EventsDropped"] = "EventsDropped";
+  P2pEvent_Tags["DriverFailed"] = "DriverFailed";
+  P2pEvent_Tags["ConnectionEstablished"] = "ConnectionEstablished";
+  P2pEvent_Tags["ConnectionClosed"] = "ConnectionClosed";
+  P2pEvent_Tags["ConnectionReplaced"] = "ConnectionReplaced";
+  P2pEvent_Tags["PeerReady"] = "PeerReady";
+  P2pEvent_Tags["IdentifyReceived"] = "IdentifyReceived";
+  P2pEvent_Tags["PingRttMeasured"] = "PingRttMeasured";
+  P2pEvent_Tags["PingTimeout"] = "PingTimeout";
+  P2pEvent_Tags["StreamReady"] = "StreamReady";
+  P2pEvent_Tags["StreamData"] = "StreamData";
+  P2pEvent_Tags["StreamRemoteWriteClosed"] = "StreamRemoteWriteClosed";
+  P2pEvent_Tags["StreamClosed"] = "StreamClosed";
+  P2pEvent_Tags["EndpointError"] = "EndpointError";
+  P2pEvent_Tags["ReachabilityChanged"] = "ReachabilityChanged";
+  P2pEvent_Tags["PublicAddressesChanged"] = "PublicAddressesChanged";
+  P2pEvent_Tags["RelayReserved"] = "RelayReserved";
+  P2pEvent_Tags["RelayReservationLost"] = "RelayReservationLost";
+  P2pEvent_Tags["PathEstablished"] = "PathEstablished";
+  P2pEvent_Tags["InboundPathEstablished"] = "InboundPathEstablished";
+  P2pEvent_Tags["PathUpgraded"] = "PathUpgraded";
+  P2pEvent_Tags["HolePunchFailed"] = "HolePunchFailed";
+  P2pEvent_Tags["ConnectFailed"] = "ConnectFailed";
+  P2pEvent_Tags["ConnectCancelled"] = "ConnectCancelled";
+  P2pEvent_Tags["InboundDirectUpgrade"] = "InboundDirectUpgrade";
+  P2pEvent_Tags["Message"] = "Message";
+  P2pEvent_Tags["PeerSubscribed"] = "PeerSubscribed";
+  P2pEvent_Tags["PeerUnsubscribed"] = "PeerUnsubscribed";
+  P2pEvent_Tags["GossipsubOutboundFailure"] = "GossipsubOutboundFailure";
+  P2pEvent_Tags["GossipsubProtocolViolation"] = "GossipsubProtocolViolation";
+  P2pEvent_Tags["PeerDiscovered"] = "PeerDiscovered";
+  P2pEvent_Tags["PeerUpdated"] = "PeerUpdated";
+  P2pEvent_Tags["PeerExpired"] = "PeerExpired";
+  P2pEvent_Tags["DiscoveryDialFailed"] = "DiscoveryDialFailed";
+  P2pEvent_Tags["DiscoveryProtocolViolation"] = "DiscoveryProtocolViolation";
+  return P2pEvent_Tags;
+}({});
+/**
+ * Event delivered by the native endpoint driver.
+ */
+export const P2pEvent = (() => {
+  /**
+   * Native event carry overflow discarded source events.
+   */
+  class EventsDropped_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.EventsDropped;
+    constructor(inner) {
+      super("P2pEvent", "EventsDropped");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new EventsDropped_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.EventsDropped;
+    }
+  }
+  /**
+   * The background driver terminated after a fatal failure.
+   */
+  class DriverFailed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.DriverFailed;
+    constructor(inner) {
+      super("P2pEvent", "DriverFailed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new DriverFailed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.DriverFailed;
+    }
+  }
+  /**
+   * A peer went from disconnected to connected over a verified connection.
+   */
+  class ConnectionEstablished_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.ConnectionEstablished;
+    constructor(inner) {
+      super("P2pEvent", "ConnectionEstablished");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new ConnectionEstablished_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.ConnectionEstablished;
+    }
+  }
+  /**
+   * The peer's last connection closed; the peer is now disconnected.
+   */
+  class ConnectionClosed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.ConnectionClosed;
+    constructor(inner) {
+      super("P2pEvent", "ConnectionClosed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new ConnectionClosed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.ConnectionClosed;
+    }
+  }
+  /**
+   * A newer connection took the peer's single connection slot from
+   * `old_conn_id`.
+   * The peer stays connected; every stream on `old_conn_id` ended with
+   * it, and a fresh `PeerReady` follows for `new_conn_id`.
+   */
+  class ConnectionReplaced_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.ConnectionReplaced;
+    constructor(inner) {
+      super("P2pEvent", "ConnectionReplaced");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new ConnectionReplaced_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.ConnectionReplaced;
+    }
+  }
+  /**
+   * A peer's connection completed Identify and is ready for application
+   * protocols. Fires once per connection; one whose `conn_id` is no longer
+   * the peer's current connection is stale.
+   */
+  class PeerReady_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PeerReady;
+    constructor(inner) {
+      super("P2pEvent", "PeerReady");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PeerReady_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PeerReady;
+    }
+  }
+  /**
+   * A peer supplied a new Identify snapshot.
+   */
+  class IdentifyReceived_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.IdentifyReceived;
+    constructor(inner) {
+      super("P2pEvent", "IdentifyReceived");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new IdentifyReceived_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.IdentifyReceived;
+    }
+  }
+  /**
+   * A ping round-trip measurement completed.
+   */
+  class PingRttMeasured_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PingRttMeasured;
+    constructor(inner) {
+      super("P2pEvent", "PingRttMeasured");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PingRttMeasured_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PingRttMeasured;
+    }
+  }
+  /**
+   * A ping timed out.
+   */
+  class PingTimeout_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PingTimeout;
+    constructor(inner) {
+      super("P2pEvent", "PingTimeout");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PingTimeout_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PingTimeout;
+    }
+  }
+  /**
+   * A custom application stream completed protocol negotiation.
+   */
+  class StreamReady_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.StreamReady;
+    constructor(inner) {
+      super("P2pEvent", "StreamReady");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new StreamReady_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.StreamReady;
+    }
+  }
+  /**
+   * Bytes arrived on a custom application stream.
+   */
+  class StreamData_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.StreamData;
+    constructor(inner) {
+      super("P2pEvent", "StreamData");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new StreamData_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.StreamData;
+    }
+  }
+  /**
+   * The remote peer half-closed its stream write side.
+   */
+  class StreamRemoteWriteClosed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.StreamRemoteWriteClosed;
+    constructor(inner) {
+      super("P2pEvent", "StreamRemoteWriteClosed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new StreamRemoteWriteClosed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.StreamRemoteWriteClosed;
+    }
+  }
+  /**
+   * A custom application stream fully closed.
+   */
+  class StreamClosed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.StreamClosed;
+    constructor(inner) {
+      super("P2pEvent", "StreamClosed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new StreamClosed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.StreamClosed;
+    }
+  }
+  /**
+   * A non-fatal endpoint error occurred.
+   */
+  class EndpointError_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.EndpointError;
+    constructor(inner) {
+      super("P2pEvent", "EndpointError");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new EndpointError_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.EndpointError;
+    }
+  }
+  /**
+   * The local reachability verdict changed.
+   */
+  class ReachabilityChanged_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.ReachabilityChanged;
+    constructor(inner) {
+      super("P2pEvent", "ReachabilityChanged");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new ReachabilityChanged_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.ReachabilityChanged;
+    }
+  }
+  /**
+   * AutoNAT confirmed a changed public address set.
+   */
+  class PublicAddressesChanged_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PublicAddressesChanged;
+    constructor(inner) {
+      super("P2pEvent", "PublicAddressesChanged");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PublicAddressesChanged_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PublicAddressesChanged;
+    }
+  }
+  /**
+   * A relay reservation was acquired or renewed.
+   */
+  class RelayReserved_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.RelayReserved;
+    constructor(inner) {
+      super("P2pEvent", "RelayReserved");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new RelayReserved_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.RelayReserved;
+    }
+  }
+  /**
+   * A relay reservation was lost.
+   */
+  class RelayReservationLost_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.RelayReservationLost;
+    constructor(inner) {
+      super("P2pEvent", "RelayReservationLost");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new RelayReservationLost_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.RelayReservationLost;
+    }
+  }
+  /**
+   * The first usable path for an attempt became available.
+   */
+  class PathEstablished_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PathEstablished;
+    constructor(inner) {
+      super("P2pEvent", "PathEstablished");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PathEstablished_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PathEstablished;
+    }
+  }
+  /**
+   * An inbound relay circuit became a usable path.
+   */
+  class InboundPathEstablished_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.InboundPathEstablished;
+    constructor(inner) {
+      super("P2pEvent", "InboundPathEstablished");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InboundPathEstablished_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.InboundPathEstablished;
+    }
+  }
+  /**
+   * A better path replaced an earlier path.
+   */
+  class PathUpgraded_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PathUpgraded;
+    constructor(inner) {
+      super("P2pEvent", "PathUpgraded");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PathUpgraded_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PathUpgraded;
+    }
+  }
+  /**
+   * One hole-punch window failed.
+   */
+  class HolePunchFailed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.HolePunchFailed;
+    constructor(inner) {
+      super("P2pEvent", "HolePunchFailed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new HolePunchFailed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.HolePunchFailed;
+    }
+  }
+  /**
+   * A connection attempt ended without a usable path.
+   */
+  class ConnectFailed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.ConnectFailed;
+    constructor(inner) {
+      super("P2pEvent", "ConnectFailed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new ConnectFailed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.ConnectFailed;
+    }
+  }
+  /**
+   * A Connection attempt was cancelled by `cancel_connect` before it
+   * settled. Terminal for that Connect ID.
+   */
+  class ConnectCancelled_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.ConnectCancelled;
+    constructor(inner) {
+      super("P2pEvent", "ConnectCancelled");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new ConnectCancelled_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.ConnectCancelled;
+    }
+  }
+  /**
+   * An inbound circuit upgraded to a direct connection.
+   */
+  class InboundDirectUpgrade_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.InboundDirectUpgrade;
+    constructor(inner) {
+      super("P2pEvent", "InboundDirectUpgrade");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InboundDirectUpgrade_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.InboundDirectUpgrade;
+    }
+  }
+  /**
+   * An accepted pubsub message arrived.
+   *
+   * When unsigned messages are enabled, `signed` can be `false`; hosts
+   * must treat both `from_peer_id` and `data` as unauthenticated unless
+   * `signed` is `true`.
+   */
+  class Message_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.Message;
+    constructor(inner) {
+      super("P2pEvent", "Message");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Message_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.Message;
+    }
+  }
+  /**
+   * A peer announced a subscription.
+   */
+  class PeerSubscribed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PeerSubscribed;
+    constructor(inner) {
+      super("P2pEvent", "PeerSubscribed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PeerSubscribed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PeerSubscribed;
+    }
+  }
+  /**
+   * A peer's subscription ended: withdrawn, or its connection closed or was replaced.
+   */
+  class PeerUnsubscribed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PeerUnsubscribed;
+    constructor(inner) {
+      super("P2pEvent", "PeerUnsubscribed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PeerUnsubscribed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PeerUnsubscribed;
+    }
+  }
+  /**
+   * Gossipsub outbound work was discarded.
+   */
+  class GossipsubOutboundFailure_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.GossipsubOutboundFailure;
+    constructor(inner) {
+      super("P2pEvent", "GossipsubOutboundFailure");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new GossipsubOutboundFailure_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.GossipsubOutboundFailure;
+    }
+  }
+  /**
+   * A peer violated the gossipsub protocol.
+   */
+  class GossipsubProtocolViolation_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.GossipsubProtocolViolation;
+    constructor(inner) {
+      super("P2pEvent", "GossipsubProtocolViolation");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new GossipsubProtocolViolation_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.GossipsubProtocolViolation;
+    }
+  }
+  /**
+   * Discovery introduced a peer.
+   */
+  class PeerDiscovered_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PeerDiscovered;
+    constructor(inner) {
+      super("P2pEvent", "PeerDiscovered");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PeerDiscovered_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PeerDiscovered;
+    }
+  }
+  /**
+   * Discovery updated a peer.
+   */
+  class PeerUpdated_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PeerUpdated;
+    constructor(inner) {
+      super("P2pEvent", "PeerUpdated");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PeerUpdated_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PeerUpdated;
+    }
+  }
+  /**
+   * A discovered peer expired or was evicted.
+   */
+  class PeerExpired_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.PeerExpired;
+    constructor(inner) {
+      super("P2pEvent", "PeerExpired");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new PeerExpired_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.PeerExpired;
+    }
+  }
+  /**
+   * An automatic discovery dial failed.
+   */
+  class DiscoveryDialFailed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.DiscoveryDialFailed;
+    constructor(inner) {
+      super("P2pEvent", "DiscoveryDialFailed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new DiscoveryDialFailed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.DiscoveryDialFailed;
+    }
+  }
+  /**
+   * A discovery source supplied an invalid claim.
+   */
+  class DiscoveryProtocolViolation_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.DiscoveryProtocolViolation;
+    constructor(inner) {
+      super("P2pEvent", "DiscoveryProtocolViolation");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new DiscoveryProtocolViolation_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.DiscoveryProtocolViolation;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "P2pEvent";
+  }
+  return Object.freeze({
+    instanceOf,
+    EventsDropped: EventsDropped_,
+    DriverFailed: DriverFailed_,
+    ConnectionEstablished: ConnectionEstablished_,
+    ConnectionClosed: ConnectionClosed_,
+    ConnectionReplaced: ConnectionReplaced_,
+    PeerReady: PeerReady_,
+    IdentifyReceived: IdentifyReceived_,
+    PingRttMeasured: PingRttMeasured_,
+    PingTimeout: PingTimeout_,
+    StreamReady: StreamReady_,
+    StreamData: StreamData_,
+    StreamRemoteWriteClosed: StreamRemoteWriteClosed_,
+    StreamClosed: StreamClosed_,
+    EndpointError: EndpointError_,
+    ReachabilityChanged: ReachabilityChanged_,
+    PublicAddressesChanged: PublicAddressesChanged_,
+    RelayReserved: RelayReserved_,
+    RelayReservationLost: RelayReservationLost_,
+    PathEstablished: PathEstablished_,
+    InboundPathEstablished: InboundPathEstablished_,
+    PathUpgraded: PathUpgraded_,
+    HolePunchFailed: HolePunchFailed_,
+    ConnectFailed: ConnectFailed_,
+    ConnectCancelled: ConnectCancelled_,
+    InboundDirectUpgrade: InboundDirectUpgrade_,
+    Message: Message_,
+    PeerSubscribed: PeerSubscribed_,
+    PeerUnsubscribed: PeerUnsubscribed_,
+    GossipsubOutboundFailure: GossipsubOutboundFailure_,
+    GossipsubProtocolViolation: GossipsubProtocolViolation_,
+    PeerDiscovered: PeerDiscovered_,
+    PeerUpdated: PeerUpdated_,
+    PeerExpired: PeerExpired_,
+    DiscoveryDialFailed: DiscoveryDialFailed_,
+    DiscoveryProtocolViolation: DiscoveryProtocolViolation_
+  });
+})();
+/**
+ * Event delivered by the native endpoint driver.
+ */
+
+// FfiConverter for enum P2pEvent
+const FfiConverterTypeP2pEvent = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return new P2pEvent.EventsDropped({
+            dropped: FfiConverterUInt64.readFromCursor(c),
+            totalDropped: FfiConverterUInt64.readFromCursor(c),
+            terminalConnectIds: FfiConverterSequenceUInt64.readFromCursor(c)
+          });
+        case 2:
+          return new P2pEvent.DriverFailed({
+            kind: FfiConverterTypeDriverFailureKind.readFromCursor(c),
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 3:
+          return new P2pEvent.ConnectionEstablished({
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c)
+          });
+        case 4:
+          return new P2pEvent.ConnectionClosed({
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c)
+          });
+        case 5:
+          return new P2pEvent.ConnectionReplaced({
+            peerId: FfiConverterString.readFromCursor(c),
+            oldConnId: FfiConverterUInt64.readFromCursor(c),
+            newConnId: FfiConverterUInt64.readFromCursor(c)
+          });
+        case 6:
+          return new P2pEvent.PeerReady({
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c),
+            protocols: FfiConverterSequenceString.readFromCursor(c)
+          });
+        case 7:
+          return new P2pEvent.IdentifyReceived({
+            peerId: FfiConverterString.readFromCursor(c),
+            info: FfiConverterTypeIdentifyInfo.readFromCursor(c)
+          });
+        case 8:
+          return new P2pEvent.PingRttMeasured({
+            peerId: FfiConverterString.readFromCursor(c),
+            rttMs: FfiConverterUInt64.readFromCursor(c)
+          });
+        case 9:
+          return new P2pEvent.PingTimeout({
+            peerId: FfiConverterString.readFromCursor(c)
+          });
+        case 10:
+          return new P2pEvent.StreamReady({
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c),
+            streamId: FfiConverterUInt64.readFromCursor(c),
+            protocolId: FfiConverterString.readFromCursor(c),
+            initiatedLocally: FfiConverterBool.readFromCursor(c)
+          });
+        case 11:
+          return new P2pEvent.StreamData({
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c),
+            streamId: FfiConverterUInt64.readFromCursor(c),
+            data: FfiConverterArrayBuffer.readFromCursor(c)
+          });
+        case 12:
+          return new P2pEvent.StreamRemoteWriteClosed({
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c),
+            streamId: FfiConverterUInt64.readFromCursor(c)
+          });
+        case 13:
+          return new P2pEvent.StreamClosed({
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c),
+            streamId: FfiConverterUInt64.readFromCursor(c)
+          });
+        case 14:
+          return new P2pEvent.EndpointError({
+            kind: FfiConverterTypeEndpointErrorKind.readFromCursor(c),
+            peerId: FfiConverterOptionalString.readFromCursor(c),
+            connId: FfiConverterOptionalUInt64.readFromCursor(c),
+            streamId: FfiConverterOptionalUInt64.readFromCursor(c),
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 15:
+          return new P2pEvent.ReachabilityChanged({
+            previous: FfiConverterTypeReachability.readFromCursor(c),
+            current: FfiConverterTypeReachability.readFromCursor(c),
+            confirmedAddrs: FfiConverterSequenceString.readFromCursor(c)
+          });
+        case 16:
+          return new P2pEvent.PublicAddressesChanged({
+            addrs: FfiConverterSequenceString.readFromCursor(c)
+          });
+        case 17:
+          return new P2pEvent.RelayReserved({
+            relayPeerId: FfiConverterString.readFromCursor(c),
+            expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c)
+          });
+        case 18:
+          return new P2pEvent.RelayReservationLost({
+            relayPeerId: FfiConverterString.readFromCursor(c)
+          });
+        case 19:
+          return new P2pEvent.PathEstablished({
+            connectId: FfiConverterUInt64.readFromCursor(c),
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c),
+            path: FfiConverterTypePathKind.readFromCursor(c)
+          });
+        case 20:
+          return new P2pEvent.InboundPathEstablished({
+            peerId: FfiConverterString.readFromCursor(c),
+            path: FfiConverterTypePathKind.readFromCursor(c)
+          });
+        case 21:
+          return new P2pEvent.PathUpgraded({
+            connectId: FfiConverterUInt64.readFromCursor(c),
+            peerId: FfiConverterString.readFromCursor(c),
+            from: FfiConverterTypePathKind.readFromCursor(c),
+            to: FfiConverterTypePathKind.readFromCursor(c)
+          });
+        case 22:
+          return new P2pEvent.HolePunchFailed({
+            connectId: FfiConverterUInt64.readFromCursor(c),
+            attempt: FfiConverterUInt32.readFromCursor(c),
+            reason: FfiConverterString.readFromCursor(c)
+          });
+        case 23:
+          return new P2pEvent.ConnectFailed({
+            connectId: FfiConverterUInt64.readFromCursor(c),
+            peerId: FfiConverterString.readFromCursor(c),
+            kind: FfiConverterTypeNatErrorKind.readFromCursor(c),
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 24:
+          return new P2pEvent.ConnectCancelled({
+            connectId: FfiConverterUInt64.readFromCursor(c),
+            peerId: FfiConverterString.readFromCursor(c)
+          });
+        case 25:
+          return new P2pEvent.InboundDirectUpgrade({
+            peerId: FfiConverterString.readFromCursor(c)
+          });
+        case 26:
+          return new P2pEvent.Message({
+            fromPeerId: FfiConverterString.readFromCursor(c),
+            topics: FfiConverterSequenceString.readFromCursor(c),
+            data: FfiConverterArrayBuffer.readFromCursor(c),
+            seqno: FfiConverterArrayBuffer.readFromCursor(c),
+            signed: FfiConverterBool.readFromCursor(c)
+          });
+        case 27:
+          return new P2pEvent.PeerSubscribed({
+            peerId: FfiConverterString.readFromCursor(c),
+            topic: FfiConverterString.readFromCursor(c)
+          });
+        case 28:
+          return new P2pEvent.PeerUnsubscribed({
+            peerId: FfiConverterString.readFromCursor(c),
+            topic: FfiConverterString.readFromCursor(c)
+          });
+        case 29:
+          return new P2pEvent.GossipsubOutboundFailure({
+            peerId: FfiConverterString.readFromCursor(c),
+            reason: FfiConverterString.readFromCursor(c)
+          });
+        case 30:
+          return new P2pEvent.GossipsubProtocolViolation({
+            peerId: FfiConverterString.readFromCursor(c),
+            reason: FfiConverterString.readFromCursor(c)
+          });
+        case 31:
+          return new P2pEvent.PeerDiscovered({
+            peerId: FfiConverterString.readFromCursor(c),
+            addrs: FfiConverterSequenceString.readFromCursor(c),
+            source: FfiConverterTypeDiscoverySource.readFromCursor(c)
+          });
+        case 32:
+          return new P2pEvent.PeerUpdated({
+            peerId: FfiConverterString.readFromCursor(c),
+            addrs: FfiConverterSequenceString.readFromCursor(c),
+            source: FfiConverterTypeDiscoverySource.readFromCursor(c)
+          });
+        case 33:
+          return new P2pEvent.PeerExpired({
+            peerId: FfiConverterString.readFromCursor(c)
+          });
+        case 34:
+          return new P2pEvent.DiscoveryDialFailed({
+            peerId: FfiConverterString.readFromCursor(c),
+            reason: FfiConverterString.readFromCursor(c)
+          });
+        case 35:
+          return new P2pEvent.DiscoveryProtocolViolation({
+            peerId: FfiConverterOptionalString.readFromCursor(c),
+            source: FfiConverterTypeDiscoverySource.readFromCursor(c),
+            reason: FfiConverterString.readFromCursor(c),
+            suppressed: FfiConverterUInt32.readFromCursor(c)
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value.tag) {
+        case P2pEvent_Tags.EventsDropped:
+          {
+            c.writeI32(1);
+            const inner = value.inner;
+            FfiConverterUInt64.writeIntoCursor(inner.dropped, c);
+            FfiConverterUInt64.writeIntoCursor(inner.totalDropped, c);
+            FfiConverterSequenceUInt64.writeIntoCursor(inner.terminalConnectIds, c);
+            return;
+          }
+        case P2pEvent_Tags.DriverFailed:
+          {
+            c.writeI32(2);
+            const inner = value.inner;
+            FfiConverterTypeDriverFailureKind.writeIntoCursor(inner.kind, c);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case P2pEvent_Tags.ConnectionEstablished:
+          {
+            c.writeI32(3);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            return;
+          }
+        case P2pEvent_Tags.ConnectionClosed:
+          {
+            c.writeI32(4);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            return;
+          }
+        case P2pEvent_Tags.ConnectionReplaced:
+          {
+            c.writeI32(5);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.oldConnId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.newConnId, c);
+            return;
+          }
+        case P2pEvent_Tags.PeerReady:
+          {
+            c.writeI32(6);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterSequenceString.writeIntoCursor(inner.protocols, c);
+            return;
+          }
+        case P2pEvent_Tags.IdentifyReceived:
+          {
+            c.writeI32(7);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypeIdentifyInfo.writeIntoCursor(inner.info, c);
+            return;
+          }
+        case P2pEvent_Tags.PingRttMeasured:
+          {
+            c.writeI32(8);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.rttMs, c);
+            return;
+          }
+        case P2pEvent_Tags.PingTimeout:
+          {
+            c.writeI32(9);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            return;
+          }
+        case P2pEvent_Tags.StreamReady:
+          {
+            c.writeI32(10);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
+            FfiConverterString.writeIntoCursor(inner.protocolId, c);
+            FfiConverterBool.writeIntoCursor(inner.initiatedLocally, c);
+            return;
+          }
+        case P2pEvent_Tags.StreamData:
+          {
+            c.writeI32(11);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
+            FfiConverterArrayBuffer.writeIntoCursor(inner.data, c);
+            return;
+          }
+        case P2pEvent_Tags.StreamRemoteWriteClosed:
+          {
+            c.writeI32(12);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
+            return;
+          }
+        case P2pEvent_Tags.StreamClosed:
+          {
+            c.writeI32(13);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
+            return;
+          }
+        case P2pEvent_Tags.EndpointError:
+          {
+            c.writeI32(14);
+            const inner = value.inner;
+            FfiConverterTypeEndpointErrorKind.writeIntoCursor(inner.kind, c);
+            FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(inner.streamId, c);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case P2pEvent_Tags.ReachabilityChanged:
+          {
+            c.writeI32(15);
+            const inner = value.inner;
+            FfiConverterTypeReachability.writeIntoCursor(inner.previous, c);
+            FfiConverterTypeReachability.writeIntoCursor(inner.current, c);
+            FfiConverterSequenceString.writeIntoCursor(inner.confirmedAddrs, c);
+            return;
+          }
+        case P2pEvent_Tags.PublicAddressesChanged:
+          {
+            c.writeI32(16);
+            const inner = value.inner;
+            FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
+            return;
+          }
+        case P2pEvent_Tags.RelayReserved:
+          {
+            c.writeI32(17);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(inner.expiresUnixSecs, c);
+            return;
+          }
+        case P2pEvent_Tags.RelayReservationLost:
+          {
+            c.writeI32(18);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
+            return;
+          }
+        case P2pEvent_Tags.PathEstablished:
+          {
+            c.writeI32(19);
+            const inner = value.inner;
+            FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
+            return;
+          }
+        case P2pEvent_Tags.InboundPathEstablished:
+          {
+            c.writeI32(20);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
+            return;
+          }
+        case P2pEvent_Tags.PathUpgraded:
+          {
+            c.writeI32(21);
+            const inner = value.inner;
+            FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypePathKind.writeIntoCursor(inner.from, c);
+            FfiConverterTypePathKind.writeIntoCursor(inner.to, c);
+            return;
+          }
+        case P2pEvent_Tags.HolePunchFailed:
+          {
+            c.writeI32(22);
+            const inner = value.inner;
+            FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+            FfiConverterUInt32.writeIntoCursor(inner.attempt, c);
+            FfiConverterString.writeIntoCursor(inner.reason, c);
+            return;
+          }
+        case P2pEvent_Tags.ConnectFailed:
+          {
+            c.writeI32(23);
+            const inner = value.inner;
+            FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypeNatErrorKind.writeIntoCursor(inner.kind, c);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case P2pEvent_Tags.ConnectCancelled:
+          {
+            c.writeI32(24);
+            const inner = value.inner;
+            FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            return;
+          }
+        case P2pEvent_Tags.InboundDirectUpgrade:
+          {
+            c.writeI32(25);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            return;
+          }
+        case P2pEvent_Tags.Message:
+          {
+            c.writeI32(26);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.fromPeerId, c);
+            FfiConverterSequenceString.writeIntoCursor(inner.topics, c);
+            FfiConverterArrayBuffer.writeIntoCursor(inner.data, c);
+            FfiConverterArrayBuffer.writeIntoCursor(inner.seqno, c);
+            FfiConverterBool.writeIntoCursor(inner.signed, c);
+            return;
+          }
+        case P2pEvent_Tags.PeerSubscribed:
+          {
+            c.writeI32(27);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterString.writeIntoCursor(inner.topic, c);
+            return;
+          }
+        case P2pEvent_Tags.PeerUnsubscribed:
+          {
+            c.writeI32(28);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterString.writeIntoCursor(inner.topic, c);
+            return;
+          }
+        case P2pEvent_Tags.GossipsubOutboundFailure:
+          {
+            c.writeI32(29);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterString.writeIntoCursor(inner.reason, c);
+            return;
+          }
+        case P2pEvent_Tags.GossipsubProtocolViolation:
+          {
+            c.writeI32(30);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterString.writeIntoCursor(inner.reason, c);
+            return;
+          }
+        case P2pEvent_Tags.PeerDiscovered:
+          {
+            c.writeI32(31);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
+            FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
+            return;
+          }
+        case P2pEvent_Tags.PeerUpdated:
+          {
+            c.writeI32(32);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
+            FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
+            return;
+          }
+        case P2pEvent_Tags.PeerExpired:
+          {
+            c.writeI32(33);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            return;
+          }
+        case P2pEvent_Tags.DiscoveryDialFailed:
+          {
+            c.writeI32(34);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterString.writeIntoCursor(inner.reason, c);
+            return;
+          }
+        case P2pEvent_Tags.DiscoveryProtocolViolation:
+          {
+            c.writeI32(35);
+            const inner = value.inner;
+            FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
+            FfiConverterString.writeIntoCursor(inner.reason, c);
+            FfiConverterUInt32.writeIntoCursor(inner.suppressed, c);
+            return;
+          }
+        default:
+          // Throwing from here means that P2pEvent_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case P2pEvent_Tags.EventsDropped:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterUInt64.allocationSize(inner.dropped);
+            size += FfiConverterUInt64.allocationSize(inner.totalDropped);
+            size += FfiConverterSequenceUInt64.allocationSize(inner.terminalConnectIds);
+            return size;
+          }
+        case P2pEvent_Tags.DriverFailed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterTypeDriverFailureKind.allocationSize(inner.kind);
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case P2pEvent_Tags.ConnectionEstablished:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.connId);
+            return size;
+          }
+        case P2pEvent_Tags.ConnectionClosed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.connId);
+            return size;
+          }
+        case P2pEvent_Tags.ConnectionReplaced:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.oldConnId);
+            size += FfiConverterUInt64.allocationSize(inner.newConnId);
+            return size;
+          }
+        case P2pEvent_Tags.PeerReady:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.connId);
+            size += FfiConverterSequenceString.allocationSize(inner.protocols);
+            return size;
+          }
+        case P2pEvent_Tags.IdentifyReceived:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterTypeIdentifyInfo.allocationSize(inner.info);
+            return size;
+          }
+        case P2pEvent_Tags.PingRttMeasured:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.rttMs);
+            return size;
+          }
+        case P2pEvent_Tags.PingTimeout:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            return size;
+          }
+        case P2pEvent_Tags.StreamReady:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.connId);
+            size += FfiConverterUInt64.allocationSize(inner.streamId);
+            size += FfiConverterString.allocationSize(inner.protocolId);
+            size += FfiConverterBool.allocationSize(inner.initiatedLocally);
+            return size;
+          }
+        case P2pEvent_Tags.StreamData:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.connId);
+            size += FfiConverterUInt64.allocationSize(inner.streamId);
+            size += FfiConverterArrayBuffer.allocationSize(inner.data);
+            return size;
+          }
+        case P2pEvent_Tags.StreamRemoteWriteClosed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.connId);
+            size += FfiConverterUInt64.allocationSize(inner.streamId);
+            return size;
+          }
+        case P2pEvent_Tags.StreamClosed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.connId);
+            size += FfiConverterUInt64.allocationSize(inner.streamId);
+            return size;
+          }
+        case P2pEvent_Tags.EndpointError:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterTypeEndpointErrorKind.allocationSize(inner.kind);
+            size += FfiConverterOptionalString.allocationSize(inner.peerId);
+            size += FfiConverterOptionalUInt64.allocationSize(inner.connId);
+            size += FfiConverterOptionalUInt64.allocationSize(inner.streamId);
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case P2pEvent_Tags.ReachabilityChanged:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterTypeReachability.allocationSize(inner.previous);
+            size += FfiConverterTypeReachability.allocationSize(inner.current);
+            size += FfiConverterSequenceString.allocationSize(inner.confirmedAddrs);
+            return size;
+          }
+        case P2pEvent_Tags.PublicAddressesChanged:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterSequenceString.allocationSize(inner.addrs);
+            return size;
+          }
+        case P2pEvent_Tags.RelayReserved:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.relayPeerId);
+            size += FfiConverterOptionalUInt64.allocationSize(inner.expiresUnixSecs);
+            return size;
+          }
+        case P2pEvent_Tags.RelayReservationLost:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.relayPeerId);
+            return size;
+          }
+        case P2pEvent_Tags.PathEstablished:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterUInt64.allocationSize(inner.connectId);
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.connId);
+            size += FfiConverterTypePathKind.allocationSize(inner.path);
+            return size;
+          }
+        case P2pEvent_Tags.InboundPathEstablished:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterTypePathKind.allocationSize(inner.path);
+            return size;
+          }
+        case P2pEvent_Tags.PathUpgraded:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterUInt64.allocationSize(inner.connectId);
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterTypePathKind.allocationSize(inner.from);
+            size += FfiConverterTypePathKind.allocationSize(inner.to);
+            return size;
+          }
+        case P2pEvent_Tags.HolePunchFailed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterUInt64.allocationSize(inner.connectId);
+            size += FfiConverterUInt32.allocationSize(inner.attempt);
+            size += FfiConverterString.allocationSize(inner.reason);
+            return size;
+          }
+        case P2pEvent_Tags.ConnectFailed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterUInt64.allocationSize(inner.connectId);
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterTypeNatErrorKind.allocationSize(inner.kind);
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case P2pEvent_Tags.ConnectCancelled:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterUInt64.allocationSize(inner.connectId);
+            size += FfiConverterString.allocationSize(inner.peerId);
+            return size;
+          }
+        case P2pEvent_Tags.InboundDirectUpgrade:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            return size;
+          }
+        case P2pEvent_Tags.Message:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.fromPeerId);
+            size += FfiConverterSequenceString.allocationSize(inner.topics);
+            size += FfiConverterArrayBuffer.allocationSize(inner.data);
+            size += FfiConverterArrayBuffer.allocationSize(inner.seqno);
+            size += FfiConverterBool.allocationSize(inner.signed);
+            return size;
+          }
+        case P2pEvent_Tags.PeerSubscribed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterString.allocationSize(inner.topic);
+            return size;
+          }
+        case P2pEvent_Tags.PeerUnsubscribed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterString.allocationSize(inner.topic);
+            return size;
+          }
+        case P2pEvent_Tags.GossipsubOutboundFailure:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterString.allocationSize(inner.reason);
+            return size;
+          }
+        case P2pEvent_Tags.GossipsubProtocolViolation:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterString.allocationSize(inner.reason);
+            return size;
+          }
+        case P2pEvent_Tags.PeerDiscovered:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterSequenceString.allocationSize(inner.addrs);
+            size += FfiConverterTypeDiscoverySource.allocationSize(inner.source);
+            return size;
+          }
+        case P2pEvent_Tags.PeerUpdated:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterSequenceString.allocationSize(inner.addrs);
+            size += FfiConverterTypeDiscoverySource.allocationSize(inner.source);
+            return size;
+          }
+        case P2pEvent_Tags.PeerExpired:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            return size;
+          }
+        case P2pEvent_Tags.DiscoveryDialFailed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterString.allocationSize(inner.reason);
+            return size;
+          }
+        case P2pEvent_Tags.DiscoveryProtocolViolation:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterOptionalString.allocationSize(inner.peerId);
+            size += FfiConverterTypeDiscoverySource.allocationSize(inner.source);
+            size += FfiConverterString.allocationSize(inner.reason);
+            size += FfiConverterUInt32.allocationSize(inner.suppressed);
+            return size;
+          }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+// FfiConverter for Array<string>
+const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
+
+// FfiConverter for Array<string> | undefined
+const FfiConverterOptionalSequenceString = new FfiConverterOptional(FfiConverterSequenceString);
+
+// FfiConverter for DiscoveryOptions | undefined
+const FfiConverterOptionalTypeDiscoveryOptions = new FfiConverterOptional(FfiConverterTypeDiscoveryOptions);
+
+// FfiConverter for MdnsOptions | undefined
+const FfiConverterOptionalTypeMdnsOptions = new FfiConverterOptional(FfiConverterTypeMdnsOptions);
+
+// FfiConverter for ArrayBuffer | undefined
+const FfiConverterOptionalBytes = new FfiConverterOptional(FfiConverterArrayBuffer);
+
+// FfiConverter for bigint | undefined
+const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
+
+// FfiConverter for Array<bigint>
+const FfiConverterSequenceUInt64 = new FfiConverterArray(FfiConverterUInt64);
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+  // Get the bindings contract version from our ComponentInterface
+  const bindingsContractVersion = 30;
+  // Get the scaffolding contract version by calling the into the dylib
+  const scaffoldingContractVersion = nativeModule().ubrn_ffi_minip2p_ffi_core_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+  }
+}
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeConnectTarget,
+    FfiConverterTypeConnectionInfo,
+    FfiConverterTypeDiscoveryOptions,
+    FfiConverterTypeDiscoverySource,
+    FfiConverterTypeDriverFailureKind,
+    FfiConverterTypeEndpointConfig,
+    FfiConverterTypeEndpointErrorKind,
+    FfiConverterTypeFfiError,
+    FfiConverterTypeIdentifyInfo,
+    FfiConverterTypeKnownPeerInfo,
+    FfiConverterTypeMdnsOptions,
+    FfiConverterTypeNatErrorKind,
+    FfiConverterTypeOpenStreamResult,
+    FfiConverterTypeP2pEvent,
+    FfiConverterTypePathKind,
+    FfiConverterTypeReachability,
+    FfiConverterTypeRelayReservationInfo
+  }
+});
+//# sourceMappingURL=minip2p_ffi_core.js.map