@minip2p/react-native 0.8.3 → 0.10.0

package/lib/module/generated/minip2p_ffi_core.js

@@ -56,8 +56,161 @@ const stringConverter = (() => {
 })();
 const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
 
+// Enum: PathKind
+export let PathKind_Tags = /*#__PURE__*/function (PathKind_Tags) {
+  PathKind_Tags["Direct"] = "Direct";
+  PathKind_Tags["Punched"] = "Punched";
+  PathKind_Tags["Relayed"] = "Relayed";
+  return PathKind_Tags;
+}({});
 /**
- * State snapshot of the transport connection selected for a peer.
+ * How an established connection was made; see `minip2p::Path`.
+ */
+export const PathKind = (() => {
+  /**
+   * A direct connection we dialed or accepted.
+   */
+  class Direct_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "PathKind";
+    tag = PathKind_Tags.Direct;
+    constructor() {
+      super("PathKind", "Direct");
+    }
+    static new() {
+      return new Direct_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === PathKind_Tags.Direct;
+    }
+  }
+  /**
+   * A direct connection made by a DCUtR hole punch.
+   */
+  class Punched_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "PathKind";
+    tag = PathKind_Tags.Punched;
+    constructor() {
+      super("PathKind", "Punched");
+    }
+    static new() {
+      return new Punched_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === PathKind_Tags.Punched;
+    }
+  }
+  /**
+   * 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,
+    Direct: Direct_,
+    Punched: Punched_,
+    Relayed: Relayed_
+  });
+})();
+/**
+ * How an established connection was made; see `minip2p::Path`.
+ */
+
+// FfiConverter for enum PathKind
+const FfiConverterTypePathKind = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return new PathKind.Direct();
+        case 2:
+          return new PathKind.Punched();
+        case 3:
+          return new PathKind.Relayed({
+            relayPeerId: FfiConverterString.readFromCursor(c)
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value.tag) {
+        case PathKind_Tags.Direct:
+          {
+            c.writeI32(1);
+            return;
+          }
+        case PathKind_Tags.Punched:
+          {
+            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.Direct:
+          {
+            return 4;
+          }
+        case PathKind_Tags.Punched:
+          {
+            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();
+})();
+
+/**
+ * State snapshot of a peer's established connection; see
+ * `minip2p::ConnectionInfo`.
  */
 
 /**
@@ -78,18 +231,22 @@ const FfiConverterTypeConnectionInfo = (() => {
   class FFIConverter extends AbstractFfiConverterByteArray {
     readFromCursor(c) {
       return {
+        peerId: FfiConverterString.readFromCursor(c),
         connId: FfiConverterUInt64.readFromCursor(c),
-        remoteAddr: FfiConverterOptionalString.readFromCursor(c),
+        remoteAddr: FfiConverterString.readFromCursor(c),
+        path: FfiConverterTypePathKind.readFromCursor(c),
         readyProtocols: FfiConverterOptionalSequenceString.readFromCursor(c)
       };
     }
     writeIntoCursor(value, c) {
+      FfiConverterString.writeIntoCursor(value.peerId, c);
       FfiConverterUInt64.writeIntoCursor(value.connId, c);
-      FfiConverterOptionalString.writeIntoCursor(value.remoteAddr, c);
+      FfiConverterString.writeIntoCursor(value.remoteAddr, c);
+      FfiConverterTypePathKind.writeIntoCursor(value.path, c);
       FfiConverterOptionalSequenceString.writeIntoCursor(value.readyProtocols, c);
     }
     allocationSize(value) {
-      return FfiConverterUInt64.allocationSize(value.connId) + FfiConverterOptionalString.allocationSize(value.remoteAddr) + FfiConverterOptionalSequenceString.allocationSize(value.readyProtocols);
+      return FfiConverterString.allocationSize(value.peerId) + FfiConverterUInt64.allocationSize(value.connId) + FfiConverterString.allocationSize(value.remoteAddr) + FfiConverterTypePathKind.allocationSize(value.path) + FfiConverterOptionalSequenceString.allocationSize(value.readyProtocols);
     }
   }
   ;
@@ -408,6 +565,165 @@ const FfiConverterTypeRelayReservationInfo = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * A connection still tracked when the closing drain ended.
+ */
+
+/**
+ * Generated factory for {@link UnfinishedConnection} record objects.
+ */
+export const UnfinishedConnection = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeUnfinishedConnection = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        connId: FfiConverterUInt64.readFromCursor(c),
+        peerId: FfiConverterOptionalString.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterUInt64.writeIntoCursor(value.connId, c);
+      FfiConverterOptionalString.writeIntoCursor(value.peerId, c);
+    }
+    allocationSize(value) {
+      return FfiConverterUInt64.allocationSize(value.connId) + FfiConverterOptionalString.allocationSize(value.peerId);
+    }
+  }
+  ;
+  return new FFIConverter();
+})();
+
+/**
+ * How the driver's closing drain ended; see [`P2pEvent::EndpointClosed`].
+ */
+export let CloseOutcome = /*#__PURE__*/function (CloseOutcome) {
+  /**
+   * Every tracked connection finished its teardown in time.
+   */
+  CloseOutcome[CloseOutcome["Drained"] = 0] = "Drained";
+  /**
+   * The stop deadline passed with connections still tracked.
+   */
+  CloseOutcome[CloseOutcome["DeadlineExpired"] = 1] = "DeadlineExpired";
+  /**
+   * Driving the transports failed and ended the drain early, or the
+   * driver panicked and dropped the endpoint without a drain.
+   */
+  CloseOutcome[CloseOutcome["Failed"] = 2] = "Failed";
+  return CloseOutcome;
+}({});
+const FfiConverterTypeCloseOutcome = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return CloseOutcome.Drained;
+        case 2:
+          return CloseOutcome.DeadlineExpired;
+        case 3:
+          return CloseOutcome.Failed;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case CloseOutcome.Drained:
+          return c.writeI32(1);
+        case CloseOutcome.DeadlineExpired:
+          return c.writeI32(2);
+        case CloseOutcome.Failed:
+          return c.writeI32(3);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * The part of an endpoint's configuration an [`FfiError::InvalidConfig`]
+ * names.
+ *
+ * A configuration mistake is fixed by changing that part; an environment
+ * failure (a socket the platform refused) is [`FfiError::Transport`]
+ * instead.
+ */
+export let ConfigCapability = /*#__PURE__*/function (ConfigCapability) {
+  /**
+   * Gossipsub settings.
+   */
+  ConfigCapability[ConfigCapability["Gossipsub"] = 0] = "Gossipsub";
+  /**
+   * mDNS settings.
+   */
+  ConfigCapability[ConfigCapability["Mdns"] = 1] = "Mdns";
+  /**
+   * Signed discovery or peer-book settings.
+   */
+  ConfigCapability[ConfigCapability["Discovery"] = 2] = "Discovery";
+  /**
+   * QUIC or TCP transport settings (limits, TLS, the TCP namespace).
+   */
+  ConfigCapability[ConfigCapability["Transport"] = 3] = "Transport";
+  /**
+   * The endpoint's own options: listen addresses, protocols, NAT and
+   * relay policy, auto-dial.
+   */
+  ConfigCapability[ConfigCapability["Options"] = 4] = "Options";
+  return ConfigCapability;
+}({});
+const FfiConverterTypeConfigCapability = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return ConfigCapability.Gossipsub;
+        case 2:
+          return ConfigCapability.Mdns;
+        case 3:
+          return ConfigCapability.Discovery;
+        case 4:
+          return ConfigCapability.Transport;
+        case 5:
+          return ConfigCapability.Options;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case ConfigCapability.Gossipsub:
+          return c.writeI32(1);
+        case ConfigCapability.Mdns:
+          return c.writeI32(2);
+        case ConfigCapability.Discovery:
+          return c.writeI32(3);
+        case ConfigCapability.Transport:
+          return c.writeI32(4);
+        case ConfigCapability.Options:
+          return c.writeI32(5);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter();
+})();
+
 // Enum: ConnectTarget
 export let ConnectTarget_Tags = /*#__PURE__*/function (ConnectTarget_Tags) {
   ConnectTarget_Tags["Peer"] = "Peer";
@@ -422,77 +738,277 @@ export let ConnectTarget_Tags = /*#__PURE__*/function (ConnectTarget_Tags) {
  */
 export const ConnectTarget = (() => {
   /**
-   * Peer ID only: the endpoint applies its discovery-book and relay
-   * policy.
+   * 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();
+})();
+
+// Enum: ConnectionCloseReason
+export let ConnectionCloseReason_Tags = /*#__PURE__*/function (ConnectionCloseReason_Tags) {
+  ConnectionCloseReason_Tags["Local"] = "Local";
+  ConnectionCloseReason_Tags["Remote"] = "Remote";
+  ConnectionCloseReason_Tags["TimedOut"] = "TimedOut";
+  ConnectionCloseReason_Tags["Stalled"] = "Stalled";
+  ConnectionCloseReason_Tags["Error"] = "Error";
+  return ConnectionCloseReason_Tags;
+}({});
+/**
+ * Why one connection ended; see `minip2p::ConnectionCloseReason`.
+ */
+export const ConnectionCloseReason = (() => {
+  /**
+   * We closed it.
+   */
+  class Local_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+    tag = ConnectionCloseReason_Tags.Local;
+    constructor() {
+      super("ConnectionCloseReason", "Local");
+    }
+    static new() {
+      return new Local_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === ConnectionCloseReason_Tags.Local;
+    }
+  }
+  /**
+   * The peer closed it with `code`: its QUIC CONNECTION_CLOSE code, or
+   * its Yamux `GoAway` code on TCP and relay circuits.
+   */
+  class Remote_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+    tag = ConnectionCloseReason_Tags.Remote;
+    constructor(inner) {
+      super("ConnectionCloseReason", "Remote");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Remote_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === ConnectionCloseReason_Tags.Remote;
+    }
+  }
+  /**
+   * The peer went silent (an idle, keepalive or handshake timeout).
+   */
+  class TimedOut_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+    tag = ConnectionCloseReason_Tags.TimedOut;
+    constructor() {
+      super("ConnectionCloseReason", "TimedOut");
+    }
+    static new() {
+      return new TimedOut_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === ConnectionCloseReason_Tags.TimedOut;
+    }
+  }
+  /**
+   * The peer stopped reading (a TCP send stall).
    */
-  class Peer_ extends UniffiEnum {
+  class Stalled_ 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);
+    [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+    tag = ConnectionCloseReason_Tags.Stalled;
+    constructor() {
+      super("ConnectionCloseReason", "Stalled");
     }
-    static new(inner) {
-      return new Peer_(inner);
+    static new() {
+      return new Stalled_();
     }
     static instanceOf(obj) {
-      return obj.tag === ConnectTarget_Tags.Peer;
+      return obj.tag === ConnectionCloseReason_Tags.Stalled;
     }
   }
   /**
-   * One or more complete direct peer addresses that all name the same
-   * peer. One address is the single-address form.
+   * Anything else that ended it.
    */
-  class Addresses_ extends UniffiEnum {
+  class Error_ extends UniffiEnum {
     /**
      * @private
      * This field is private and should not be used, use `tag` instead.
      */
-    [uniffiTypeNameSymbol] = "ConnectTarget";
-    tag = ConnectTarget_Tags.Addresses;
+    [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+    tag = ConnectionCloseReason_Tags.Error;
     constructor(inner) {
-      super("ConnectTarget", "Addresses");
+      super("ConnectionCloseReason", "Error");
       this.inner = Object.freeze(inner);
     }
     static new(inner) {
-      return new Addresses_(inner);
+      return new Error_(inner);
     }
     static instanceOf(obj) {
-      return obj.tag === ConnectTarget_Tags.Addresses;
+      return obj.tag === ConnectionCloseReason_Tags.Error;
     }
   }
   function instanceOf(obj) {
-    return obj[uniffiTypeNameSymbol] === "ConnectTarget";
+    return obj[uniffiTypeNameSymbol] === "ConnectionCloseReason";
   }
   return Object.freeze({
     instanceOf,
-    Peer: Peer_,
-    Addresses: Addresses_
+    Local: Local_,
+    Remote: Remote_,
+    TimedOut: TimedOut_,
+    Stalled: Stalled_,
+    Error: Error_
   });
 })();
 /**
- * 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.
+ * Why one connection ended; see `minip2p::ConnectionCloseReason`.
  */
 
-// FfiConverter for enum ConnectTarget
-const FfiConverterTypeConnectTarget = (() => {
+// FfiConverter for enum ConnectionCloseReason
+const FfiConverterTypeConnectionCloseReason = (() => {
   class FFIConverter extends AbstractFfiConverterByteArray {
     readFromCursor(c) {
       switch (c.readI32()) {
         case 1:
-          return new ConnectTarget.Peer({
-            peerId: FfiConverterString.readFromCursor(c)
-          });
+          return new ConnectionCloseReason.Local();
         case 2:
-          return new ConnectTarget.Addresses({
-            addresses: FfiConverterSequenceString.readFromCursor(c)
+          return new ConnectionCloseReason.Remote({
+            code: FfiConverterUInt64.readFromCursor(c)
+          });
+        case 3:
+          return new ConnectionCloseReason.TimedOut();
+        case 4:
+          return new ConnectionCloseReason.Stalled();
+        case 5:
+          return new ConnectionCloseReason.Error({
+            message: FfiConverterString.readFromCursor(c)
           });
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
@@ -500,39 +1016,66 @@ const FfiConverterTypeConnectTarget = (() => {
     }
     writeIntoCursor(value, c) {
       switch (value.tag) {
-        case ConnectTarget_Tags.Peer:
+        case ConnectionCloseReason_Tags.Local:
           {
             c.writeI32(1);
-            const inner = value.inner;
-            FfiConverterString.writeIntoCursor(inner.peerId, c);
             return;
           }
-        case ConnectTarget_Tags.Addresses:
+        case ConnectionCloseReason_Tags.Remote:
           {
             c.writeI32(2);
             const inner = value.inner;
-            FfiConverterSequenceString.writeIntoCursor(inner.addresses, c);
+            FfiConverterUInt64.writeIntoCursor(inner.code, c);
+            return;
+          }
+        case ConnectionCloseReason_Tags.TimedOut:
+          {
+            c.writeI32(3);
+            return;
+          }
+        case ConnectionCloseReason_Tags.Stalled:
+          {
+            c.writeI32(4);
+            return;
+          }
+        case ConnectionCloseReason_Tags.Error:
+          {
+            c.writeI32(5);
+            const inner = value.inner;
+            FfiConverterString.writeIntoCursor(inner.message, c);
             return;
           }
         default:
-          // Throwing from here means that ConnectTarget_Tags hasn't matched an ordinal.
+          // Throwing from here means that ConnectionCloseReason_Tags hasn't matched an ordinal.
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
     allocationSize(value) {
       switch (value.tag) {
-        case ConnectTarget_Tags.Peer:
+        case ConnectionCloseReason_Tags.Local:
+          {
+            return 4;
+          }
+        case ConnectionCloseReason_Tags.Remote:
           {
             const inner = value.inner;
             let size = 4;
-            size += FfiConverterString.allocationSize(inner.peerId);
+            size += FfiConverterUInt64.allocationSize(inner.code);
             return size;
           }
-        case ConnectTarget_Tags.Addresses:
+        case ConnectionCloseReason_Tags.TimedOut:
+          {
+            return 4;
+          }
+        case ConnectionCloseReason_Tags.Stalled:
+          {
+            return 4;
+          }
+        case ConnectionCloseReason_Tags.Error:
           {
             const inner = value.inner;
             let size = 4;
-            size += FfiConverterSequenceString.allocationSize(inner.addresses);
+            size += FfiConverterString.allocationSize(inner.message);
             return size;
           }
         default:
@@ -798,7 +1341,8 @@ export const FfiError = (() => {
     }
   }
   /**
-   * Endpoint configuration was internally inconsistent.
+   * Endpoint configuration was invalid; `capability` names the part of
+   * it that was.
    */
   class InvalidConfig_ extends UniffiError {
     /**
@@ -1006,7 +1550,8 @@ export const FfiError = (() => {
     }
   }
   /**
-   * A synchronous transport operation failed.
+   * A synchronous transport operation failed, or the platform refused a
+   * socket the endpoint needed (a port in use, say).
    */
   class Transport_ extends UniffiError {
     /**
@@ -1121,6 +1666,7 @@ const FfiConverterTypeFfiError = (() => {
           return new FfiError.Stopped();
         case 3:
           return new FfiError.InvalidConfig({
+            capability: FfiConverterTypeConfigCapability.readFromCursor(c),
             detail: FfiConverterString.readFromCursor(c)
           });
         case 4:
@@ -1179,6 +1725,7 @@ const FfiConverterTypeFfiError = (() => {
           {
             c.writeI32(3);
             const inner = value.inner;
+            FfiConverterTypeConfigCapability.writeIntoCursor(inner.capability, c);
             FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
@@ -1267,6 +1814,7 @@ const FfiConverterTypeFfiError = (() => {
           {
             const inner = value.inner;
             let size = 4;
+            size += FfiConverterTypeConfigCapability.allocationSize(inner.capability);
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
@@ -1342,6 +1890,88 @@ const FfiConverterTypeFfiError = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * Category of an mDNS failure.
+ */
+export let MdnsFailureKind = /*#__PURE__*/function (MdnsFailureKind) {
+  /**
+   * The platform cannot provide mDNS sockets.
+   */
+  MdnsFailureKind[MdnsFailureKind["Unsupported"] = 0] = "Unsupported";
+  /**
+   * An interface has no usable address.
+   */
+  MdnsFailureKind[MdnsFailureKind["NoInterfaceAddress"] = 1] = "NoInterfaceAddress";
+  /**
+   * A send named an interface that has gone away.
+   */
+  MdnsFailureKind[MdnsFailureKind["UnknownInterface"] = 2] = "UnknownInterface";
+  /**
+   * A goodbye could not be sent before shutdown gave up on a full send
+   * buffer.
+   */
+  MdnsFailureKind[MdnsFailureKind["Congested"] = 3] = "Congested";
+  /**
+   * A datagram is larger than the carrier can ever send.
+   */
+  MdnsFailureKind[MdnsFailureKind["Oversized"] = 4] = "Oversized";
+  /**
+   * The interface id space is exhausted.
+   */
+  MdnsFailureKind[MdnsFailureKind["InterfaceIdsExhausted"] = 5] = "InterfaceIdsExhausted";
+  /**
+   * Platform I/O failed.
+   */
+  MdnsFailureKind[MdnsFailureKind["Io"] = 6] = "Io";
+  return MdnsFailureKind;
+}({});
+const FfiConverterTypeMdnsFailureKind = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return MdnsFailureKind.Unsupported;
+        case 2:
+          return MdnsFailureKind.NoInterfaceAddress;
+        case 3:
+          return MdnsFailureKind.UnknownInterface;
+        case 4:
+          return MdnsFailureKind.Congested;
+        case 5:
+          return MdnsFailureKind.Oversized;
+        case 6:
+          return MdnsFailureKind.InterfaceIdsExhausted;
+        case 7:
+          return MdnsFailureKind.Io;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case MdnsFailureKind.Unsupported:
+          return c.writeI32(1);
+        case MdnsFailureKind.NoInterfaceAddress:
+          return c.writeI32(2);
+        case MdnsFailureKind.UnknownInterface:
+          return c.writeI32(3);
+        case MdnsFailureKind.Congested:
+          return c.writeI32(4);
+        case MdnsFailureKind.Oversized:
+          return c.writeI32(5);
+        case MdnsFailureKind.InterfaceIdsExhausted:
+          return c.writeI32(6);
+        case MdnsFailureKind.Io:
+          return c.writeI32(7);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * Category of a failed NAT connection attempt.
  */
@@ -1428,182 +2058,30 @@ export let Reachability = /*#__PURE__*/function (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;
-          }
+      switch (c.readI32()) {
+        case 1:
+          return Reachability.Unknown;
+        case 2:
+          return Reachability.Public;
+        case 3:
+          return Reachability.Private;
         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();
+    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();
 })();
@@ -1612,6 +2090,7 @@ const FfiConverterTypePathKind = (() => {
 export let P2pEvent_Tags = /*#__PURE__*/function (P2pEvent_Tags) {
   P2pEvent_Tags["EventsDropped"] = "EventsDropped";
   P2pEvent_Tags["DriverFailed"] = "DriverFailed";
+  P2pEvent_Tags["EndpointClosed"] = "EndpointClosed";
   P2pEvent_Tags["ConnectionEstablished"] = "ConnectionEstablished";
   P2pEvent_Tags["ConnectionClosed"] = "ConnectionClosed";
   P2pEvent_Tags["ConnectionReplaced"] = "ConnectionReplaced";
@@ -1646,6 +2125,8 @@ export let P2pEvent_Tags = /*#__PURE__*/function (P2pEvent_Tags) {
   P2pEvent_Tags["PeerUpdated"] = "PeerUpdated";
   P2pEvent_Tags["PeerExpired"] = "PeerExpired";
   P2pEvent_Tags["DiscoveryDialFailed"] = "DiscoveryDialFailed";
+  P2pEvent_Tags["MdnsFailed"] = "MdnsFailed";
+  P2pEvent_Tags["MdnsRecovered"] = "MdnsRecovered";
   P2pEvent_Tags["DiscoveryProtocolViolation"] = "DiscoveryProtocolViolation";
   return P2pEvent_Tags;
 }({});
@@ -1695,6 +2176,29 @@ export const P2pEvent = (() => {
       return obj.tag === P2pEvent_Tags.DriverFailed;
     }
   }
+  /**
+   * The driver finished shutting down: its last event, after
+   * [`P2pEndpoint::stop`](crate::P2pEndpoint::stop) or a
+   * [`P2pEvent::DriverFailed`], when a failed driver tears down at once.
+   */
+  class EndpointClosed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.EndpointClosed;
+    constructor(inner) {
+      super("P2pEvent", "EndpointClosed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new EndpointClosed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.EndpointClosed;
+    }
+  }
   /**
    * A peer went from disconnected to connected over a verified connection.
    */
@@ -2422,6 +2926,50 @@ export const P2pEvent = (() => {
       return obj.tag === P2pEvent_Tags.DiscoveryDialFailed;
     }
   }
+  /**
+   * mDNS hit a hard failure. mDNS keeps running and retries; reported
+   * once per change in failure state, and followed by `MdnsRecovered`
+   * once a retry succeeds. A goodbye that failed during shutdown is
+   * final.
+   */
+  class MdnsFailed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.MdnsFailed;
+    constructor(inner) {
+      super("P2pEvent", "MdnsFailed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new MdnsFailed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.MdnsFailed;
+    }
+  }
+  /**
+   * mDNS recovered from its last `MdnsFailed`.
+   */
+  class MdnsRecovered_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.MdnsRecovered;
+    constructor() {
+      super("P2pEvent", "MdnsRecovered");
+    }
+    static new() {
+      return new MdnsRecovered_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.MdnsRecovered;
+    }
+  }
   /**
    * A discovery source supplied an invalid claim.
    */
@@ -2450,6 +2998,7 @@ export const P2pEvent = (() => {
     instanceOf,
     EventsDropped: EventsDropped_,
     DriverFailed: DriverFailed_,
+    EndpointClosed: EndpointClosed_,
     ConnectionEstablished: ConnectionEstablished_,
     ConnectionClosed: ConnectionClosed_,
     ConnectionReplaced: ConnectionReplaced_,
@@ -2484,6 +3033,8 @@ export const P2pEvent = (() => {
     PeerUpdated: PeerUpdated_,
     PeerExpired: PeerExpired_,
     DiscoveryDialFailed: DiscoveryDialFailed_,
+    MdnsFailed: MdnsFailed_,
+    MdnsRecovered: MdnsRecovered_,
     DiscoveryProtocolViolation: DiscoveryProtocolViolation_
   });
 })();
@@ -2508,45 +3059,51 @@ const FfiConverterTypeP2pEvent = (() => {
             detail: FfiConverterString.readFromCursor(c)
           });
         case 3:
+          return new P2pEvent.EndpointClosed({
+            outcome: FfiConverterTypeCloseOutcome.readFromCursor(c),
+            unfinished: FfiConverterSequenceTypeUnfinishedConnection.readFromCursor(c)
+          });
+        case 4:
           return new P2pEvent.ConnectionEstablished({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 4:
+        case 5:
           return new P2pEvent.ConnectionClosed({
             peerId: FfiConverterString.readFromCursor(c),
-            connId: FfiConverterUInt64.readFromCursor(c)
+            connId: FfiConverterUInt64.readFromCursor(c),
+            reason: FfiConverterTypeConnectionCloseReason.readFromCursor(c)
           });
-        case 5:
+        case 6:
           return new P2pEvent.ConnectionReplaced({
             peerId: FfiConverterString.readFromCursor(c),
             oldConnId: FfiConverterUInt64.readFromCursor(c),
             newConnId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 6:
+        case 7:
           return new P2pEvent.PeerReady({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             protocols: FfiConverterSequenceString.readFromCursor(c)
           });
-        case 7:
+        case 8:
           return new P2pEvent.IdentifyReceived({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             info: FfiConverterTypeIdentifyInfo.readFromCursor(c)
           });
-        case 8:
+        case 9:
           return new P2pEvent.PingRttMeasured({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             rttMs: FfiConverterUInt64.readFromCursor(c)
           });
-        case 9:
+        case 10:
           return new P2pEvent.PingTimeout({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 10:
+        case 11:
           return new P2pEvent.StreamReady({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
@@ -2554,39 +3111,39 @@ const FfiConverterTypeP2pEvent = (() => {
             protocolId: FfiConverterString.readFromCursor(c),
             initiatedLocally: FfiConverterBool.readFromCursor(c)
           });
-        case 11:
+        case 12:
           return new P2pEvent.StreamData({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             streamId: FfiConverterUInt64.readFromCursor(c),
             data: FfiConverterArrayBuffer.readFromCursor(c)
           });
-        case 12:
+        case 13:
           return new P2pEvent.StreamWriteAccepted({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             streamId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 13:
+        case 14:
           return new P2pEvent.StreamWriteStopped({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             streamId: FfiConverterUInt64.readFromCursor(c),
             errorCode: FfiConverterUInt64.readFromCursor(c)
           });
-        case 14:
+        case 15:
           return new P2pEvent.StreamRemoteWriteClosed({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             streamId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 15:
+        case 16:
           return new P2pEvent.StreamClosed({
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             streamId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 16:
+        case 17:
           return new P2pEvent.EndpointError({
             kind: FfiConverterTypeEndpointErrorKind.readFromCursor(c),
             peerId: FfiConverterOptionalString.readFromCursor(c),
@@ -2594,39 +3151,39 @@ const FfiConverterTypeP2pEvent = (() => {
             streamId: FfiConverterOptionalUInt64.readFromCursor(c),
             detail: FfiConverterString.readFromCursor(c)
           });
-        case 17:
+        case 18:
           return new P2pEvent.ReachabilityChanged({
             previous: FfiConverterTypeReachability.readFromCursor(c),
             current: FfiConverterTypeReachability.readFromCursor(c),
             confirmedAddrs: FfiConverterSequenceString.readFromCursor(c)
           });
-        case 18:
+        case 19:
           return new P2pEvent.PublicAddressesChanged({
             addrs: FfiConverterSequenceString.readFromCursor(c)
           });
-        case 19:
+        case 20:
           return new P2pEvent.RelayReserved({
             relayPeerId: FfiConverterString.readFromCursor(c),
             expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c)
           });
-        case 20:
+        case 21:
           return new P2pEvent.RelayReservationLost({
             relayPeerId: FfiConverterString.readFromCursor(c)
           });
-        case 21:
+        case 22:
           return new P2pEvent.PathEstablished({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             path: FfiConverterTypePathKind.readFromCursor(c)
           });
-        case 22:
+        case 23:
           return new P2pEvent.InboundPathEstablished({
             peerId: FfiConverterString.readFromCursor(c),
             path: FfiConverterTypePathKind.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 23:
+        case 24:
           return new P2pEvent.PathUpgraded({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c),
@@ -2635,31 +3192,31 @@ const FfiConverterTypeP2pEvent = (() => {
             oldConnId: FfiConverterUInt64.readFromCursor(c),
             newConnId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 24:
+        case 25:
           return new P2pEvent.HolePunchFailed({
             connectId: FfiConverterUInt64.readFromCursor(c),
             attempt: FfiConverterUInt32.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 25:
+        case 26:
           return new P2pEvent.ConnectFailed({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c),
             kind: FfiConverterTypeNatErrorKind.readFromCursor(c),
             detail: FfiConverterString.readFromCursor(c)
           });
-        case 26:
+        case 27:
           return new P2pEvent.ConnectCancelled({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c)
           });
-        case 27:
+        case 28:
           return new P2pEvent.InboundDirectUpgrade({
             peerId: FfiConverterString.readFromCursor(c),
             oldConnId: FfiConverterUInt64.readFromCursor(c),
             newConnId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 28:
+        case 29:
           return new P2pEvent.Message({
             fromPeerId: FfiConverterString.readFromCursor(c),
             topics: FfiConverterSequenceString.readFromCursor(c),
@@ -2667,48 +3224,55 @@ const FfiConverterTypeP2pEvent = (() => {
             seqno: FfiConverterArrayBuffer.readFromCursor(c),
             signed: FfiConverterBool.readFromCursor(c)
           });
-        case 29:
+        case 30:
           return new P2pEvent.PeerSubscribed({
             peerId: FfiConverterString.readFromCursor(c),
             topic: FfiConverterString.readFromCursor(c)
           });
-        case 30:
+        case 31:
           return new P2pEvent.PeerUnsubscribed({
             peerId: FfiConverterString.readFromCursor(c),
             topic: FfiConverterString.readFromCursor(c)
           });
-        case 31:
+        case 32:
           return new P2pEvent.GossipsubOutboundFailure({
             peerId: FfiConverterString.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 32:
+        case 33:
           return new P2pEvent.GossipsubProtocolViolation({
             peerId: FfiConverterString.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 33:
+        case 34:
           return new P2pEvent.PeerDiscovered({
             peerId: FfiConverterString.readFromCursor(c),
             addrs: FfiConverterSequenceString.readFromCursor(c),
             source: FfiConverterTypeDiscoverySource.readFromCursor(c)
           });
-        case 34:
+        case 35:
           return new P2pEvent.PeerUpdated({
             peerId: FfiConverterString.readFromCursor(c),
             addrs: FfiConverterSequenceString.readFromCursor(c),
             source: FfiConverterTypeDiscoverySource.readFromCursor(c)
           });
-        case 35:
+        case 36:
           return new P2pEvent.PeerExpired({
             peerId: FfiConverterString.readFromCursor(c)
           });
-        case 36:
+        case 37:
           return new P2pEvent.DiscoveryDialFailed({
             peerId: FfiConverterString.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 37:
+        case 38:
+          return new P2pEvent.MdnsFailed({
+            kind: FfiConverterTypeMdnsFailureKind.readFromCursor(c),
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 39:
+          return new P2pEvent.MdnsRecovered();
+        case 40:
           return new P2pEvent.DiscoveryProtocolViolation({
             peerId: FfiConverterOptionalString.readFromCursor(c),
             source: FfiConverterTypeDiscoverySource.readFromCursor(c),
@@ -2738,25 +3302,34 @@ const FfiConverterTypeP2pEvent = (() => {
             FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
-        case P2pEvent_Tags.ConnectionEstablished:
+        case P2pEvent_Tags.EndpointClosed:
           {
             c.writeI32(3);
             const inner = value.inner;
+            FfiConverterTypeCloseOutcome.writeIntoCursor(inner.outcome, c);
+            FfiConverterSequenceTypeUnfinishedConnection.writeIntoCursor(inner.unfinished, c);
+            return;
+          }
+        case P2pEvent_Tags.ConnectionEstablished:
+          {
+            c.writeI32(4);
+            const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
             return;
           }
         case P2pEvent_Tags.ConnectionClosed:
           {
-            c.writeI32(4);
+            c.writeI32(5);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterTypeConnectionCloseReason.writeIntoCursor(inner.reason, c);
             return;
           }
         case P2pEvent_Tags.ConnectionReplaced:
           {
-            c.writeI32(5);
+            c.writeI32(6);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.oldConnId, c);
@@ -2765,7 +3338,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerReady:
           {
-            c.writeI32(6);
+            c.writeI32(7);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -2774,7 +3347,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.IdentifyReceived:
           {
-            c.writeI32(7);
+            c.writeI32(8);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -2783,7 +3356,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PingRttMeasured:
           {
-            c.writeI32(8);
+            c.writeI32(9);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -2792,7 +3365,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PingTimeout:
           {
-            c.writeI32(9);
+            c.writeI32(10);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -2800,7 +3373,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.StreamReady:
           {
-            c.writeI32(10);
+            c.writeI32(11);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -2811,7 +3384,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.StreamData:
           {
-            c.writeI32(11);
+            c.writeI32(12);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -2821,7 +3394,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.StreamWriteAccepted:
           {
-            c.writeI32(12);
+            c.writeI32(13);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -2830,7 +3403,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.StreamWriteStopped:
           {
-            c.writeI32(13);
+            c.writeI32(14);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -2840,7 +3413,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.StreamRemoteWriteClosed:
           {
-            c.writeI32(14);
+            c.writeI32(15);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -2849,7 +3422,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.StreamClosed:
           {
-            c.writeI32(15);
+            c.writeI32(16);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -2858,7 +3431,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.EndpointError:
           {
-            c.writeI32(16);
+            c.writeI32(17);
             const inner = value.inner;
             FfiConverterTypeEndpointErrorKind.writeIntoCursor(inner.kind, c);
             FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
@@ -2869,7 +3442,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.ReachabilityChanged:
           {
-            c.writeI32(17);
+            c.writeI32(18);
             const inner = value.inner;
             FfiConverterTypeReachability.writeIntoCursor(inner.previous, c);
             FfiConverterTypeReachability.writeIntoCursor(inner.current, c);
@@ -2878,14 +3451,14 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PublicAddressesChanged:
           {
-            c.writeI32(18);
+            c.writeI32(19);
             const inner = value.inner;
             FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
             return;
           }
         case P2pEvent_Tags.RelayReserved:
           {
-            c.writeI32(19);
+            c.writeI32(20);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
             FfiConverterOptionalUInt64.writeIntoCursor(inner.expiresUnixSecs, c);
@@ -2893,14 +3466,14 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.RelayReservationLost:
           {
-            c.writeI32(20);
+            c.writeI32(21);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
             return;
           }
         case P2pEvent_Tags.PathEstablished:
           {
-            c.writeI32(21);
+            c.writeI32(22);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -2910,7 +3483,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.InboundPathEstablished:
           {
-            c.writeI32(22);
+            c.writeI32(23);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
@@ -2919,7 +3492,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PathUpgraded:
           {
-            c.writeI32(23);
+            c.writeI32(24);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -2931,7 +3504,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.HolePunchFailed:
           {
-            c.writeI32(24);
+            c.writeI32(25);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterUInt32.writeIntoCursor(inner.attempt, c);
@@ -2940,7 +3513,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.ConnectFailed:
           {
-            c.writeI32(25);
+            c.writeI32(26);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -2950,7 +3523,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.ConnectCancelled:
           {
-            c.writeI32(26);
+            c.writeI32(27);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -2958,7 +3531,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.InboundDirectUpgrade:
           {
-            c.writeI32(27);
+            c.writeI32(28);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.oldConnId, c);
@@ -2967,7 +3540,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.Message:
           {
-            c.writeI32(28);
+            c.writeI32(29);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.fromPeerId, c);
             FfiConverterSequenceString.writeIntoCursor(inner.topics, c);
@@ -2978,7 +3551,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerSubscribed:
           {
-            c.writeI32(29);
+            c.writeI32(30);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.topic, c);
@@ -2986,7 +3559,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerUnsubscribed:
           {
-            c.writeI32(30);
+            c.writeI32(31);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.topic, c);
@@ -2994,7 +3567,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.GossipsubOutboundFailure:
           {
-            c.writeI32(31);
+            c.writeI32(32);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.reason, c);
@@ -3002,7 +3575,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.GossipsubProtocolViolation:
           {
-            c.writeI32(32);
+            c.writeI32(33);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.reason, c);
@@ -3010,7 +3583,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerDiscovered:
           {
-            c.writeI32(33);
+            c.writeI32(34);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
@@ -3019,7 +3592,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerUpdated:
           {
-            c.writeI32(34);
+            c.writeI32(35);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
@@ -3028,22 +3601,35 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerExpired:
           {
-            c.writeI32(35);
+            c.writeI32(36);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             return;
           }
         case P2pEvent_Tags.DiscoveryDialFailed:
           {
-            c.writeI32(36);
+            c.writeI32(37);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.reason, c);
             return;
           }
+        case P2pEvent_Tags.MdnsFailed:
+          {
+            c.writeI32(38);
+            const inner = value.inner;
+            FfiConverterTypeMdnsFailureKind.writeIntoCursor(inner.kind, c);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case P2pEvent_Tags.MdnsRecovered:
+          {
+            c.writeI32(39);
+            return;
+          }
         case P2pEvent_Tags.DiscoveryProtocolViolation:
           {
-            c.writeI32(37);
+            c.writeI32(40);
             const inner = value.inner;
             FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
             FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
@@ -3075,6 +3661,14 @@ const FfiConverterTypeP2pEvent = (() => {
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
+        case P2pEvent_Tags.EndpointClosed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterTypeCloseOutcome.allocationSize(inner.outcome);
+            size += FfiConverterSequenceTypeUnfinishedConnection.allocationSize(inner.unfinished);
+            return size;
+          }
         case P2pEvent_Tags.ConnectionEstablished:
           {
             const inner = value.inner;
@@ -3089,6 +3683,7 @@ const FfiConverterTypeP2pEvent = (() => {
             let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterUInt64.allocationSize(inner.connId);
+            size += FfiConverterTypeConnectionCloseReason.allocationSize(inner.reason);
             return size;
           }
         case P2pEvent_Tags.ConnectionReplaced:
@@ -3378,6 +3973,18 @@ const FfiConverterTypeP2pEvent = (() => {
             size += FfiConverterString.allocationSize(inner.reason);
             return size;
           }
+        case P2pEvent_Tags.MdnsFailed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterTypeMdnsFailureKind.allocationSize(inner.kind);
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case P2pEvent_Tags.MdnsRecovered:
+          {
+            return 4;
+          }
         case P2pEvent_Tags.DiscoveryProtocolViolation:
           {
             const inner = value.inner;
@@ -3396,15 +4003,15 @@ const FfiConverterTypeP2pEvent = (() => {
   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 string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
 // FfiConverter for DiscoveryOptions | undefined
 const FfiConverterOptionalTypeDiscoveryOptions = new FfiConverterOptional(FfiConverterTypeDiscoveryOptions);
 
@@ -3420,6 +4027,9 @@ const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
 // FfiConverter for Array<bigint>
 const FfiConverterSequenceUInt64 = new FfiConverterArray(FfiConverterUInt64);
 
+// FfiConverter for Array<UnfinishedConnection>
+const FfiConverterSequenceTypeUnfinishedConnection = new FfiConverterArray(FfiConverterTypeUnfinishedConnection);
+
 /**
  * This should be called before anything else.
  *
@@ -3442,7 +4052,10 @@ function uniffiEnsureInitialized() {
 export default Object.freeze({
   initialize: uniffiEnsureInitialized,
   converters: {
+    FfiConverterTypeCloseOutcome,
+    FfiConverterTypeConfigCapability,
     FfiConverterTypeConnectTarget,
+    FfiConverterTypeConnectionCloseReason,
     FfiConverterTypeConnectionInfo,
     FfiConverterTypeDiscoveryOptions,
     FfiConverterTypeDiscoverySource,
@@ -3452,13 +4065,15 @@ export default Object.freeze({
     FfiConverterTypeFfiError,
     FfiConverterTypeIdentifyInfo,
     FfiConverterTypeKnownPeerInfo,
+    FfiConverterTypeMdnsFailureKind,
     FfiConverterTypeMdnsOptions,
     FfiConverterTypeNatErrorKind,
     FfiConverterTypeOpenStreamResult,
     FfiConverterTypeP2pEvent,
     FfiConverterTypePathKind,
     FfiConverterTypeReachability,
-    FfiConverterTypeRelayReservationInfo
+    FfiConverterTypeRelayReservationInfo,
+    FfiConverterTypeUnfinishedConnection
   }
 });
 //# sourceMappingURL=minip2p_ffi_core.js.map