@minip2p/react-native 0.9.1 → 0.10.1

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,94 @@ 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.
@@ -614,6 +859,233 @@ const FfiConverterTypeConnectTarget = (() => {
   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 Stalled_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+    tag = ConnectionCloseReason_Tags.Stalled;
+    constructor() {
+      super("ConnectionCloseReason", "Stalled");
+    }
+    static new() {
+      return new Stalled_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === ConnectionCloseReason_Tags.Stalled;
+    }
+  }
+  /**
+   * Anything else that ended it.
+   */
+  class Error_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+    tag = ConnectionCloseReason_Tags.Error;
+    constructor(inner) {
+      super("ConnectionCloseReason", "Error");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Error_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === ConnectionCloseReason_Tags.Error;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "ConnectionCloseReason";
+  }
+  return Object.freeze({
+    instanceOf,
+    Local: Local_,
+    Remote: Remote_,
+    TimedOut: TimedOut_,
+    Stalled: Stalled_,
+    Error: Error_
+  });
+})();
+/**
+ * Why one connection ended; see `minip2p::ConnectionCloseReason`.
+ */
+
+// FfiConverter for enum ConnectionCloseReason
+const FfiConverterTypeConnectionCloseReason = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return new ConnectionCloseReason.Local();
+        case 2:
+          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();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value.tag) {
+        case ConnectionCloseReason_Tags.Local:
+          {
+            c.writeI32(1);
+            return;
+          }
+        case ConnectionCloseReason_Tags.Remote:
+          {
+            c.writeI32(2);
+            const inner = value.inner;
+            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 ConnectionCloseReason_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case ConnectionCloseReason_Tags.Local:
+          {
+            return 4;
+          }
+        case ConnectionCloseReason_Tags.Remote:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterUInt64.allocationSize(inner.code);
+            return size;
+          }
+        case ConnectionCloseReason_Tags.TimedOut:
+          {
+            return 4;
+          }
+        case ConnectionCloseReason_Tags.Stalled:
+          {
+            return 4;
+          }
+        case ConnectionCloseReason_Tags.Error:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterString.allocationSize(inner.message);
+            return size;
+          }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * Source that contributed a discovery observation.
  */
@@ -1592,175 +2064,23 @@ const FfiConverterTypeReachability = (() => {
         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)
-          });
+          return Reachability.Private;
         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();
+      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) {
-      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 4;
     }
   }
   return new FFIConverter();
@@ -1770,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";
@@ -1785,6 +2106,7 @@ export let P2pEvent_Tags = /*#__PURE__*/function (P2pEvent_Tags) {
   P2pEvent_Tags["StreamClosed"] = "StreamClosed";
   P2pEvent_Tags["EndpointError"] = "EndpointError";
   P2pEvent_Tags["ReachabilityChanged"] = "ReachabilityChanged";
+  P2pEvent_Tags["ListenAddressesChanged"] = "ListenAddressesChanged";
   P2pEvent_Tags["PublicAddressesChanged"] = "PublicAddressesChanged";
   P2pEvent_Tags["RelayReserved"] = "RelayReserved";
   P2pEvent_Tags["RelayReservationLost"] = "RelayReservationLost";
@@ -1855,6 +2177,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.
    */
@@ -2177,6 +2522,30 @@ export const P2pEvent = (() => {
       return obj.tag === P2pEvent_Tags.ReachabilityChanged;
     }
   }
+  /**
+   * The listen set changed without a `listen` call, as when a
+   * WebTransport listener's certificate rotates: `addrs` is the whole new
+   * set, with `/p2p/<local>`, for the app to republish. External and
+   * public address changes never fire it.
+   */
+  class ListenAddressesChanged_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.ListenAddressesChanged;
+    constructor(inner) {
+      super("P2pEvent", "ListenAddressesChanged");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new ListenAddressesChanged_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.ListenAddressesChanged;
+    }
+  }
   /**
    * AutoNAT confirmed a changed public address set.
    */
@@ -2654,6 +3023,7 @@ export const P2pEvent = (() => {
     instanceOf,
     EventsDropped: EventsDropped_,
     DriverFailed: DriverFailed_,
+    EndpointClosed: EndpointClosed_,
     ConnectionEstablished: ConnectionEstablished_,
     ConnectionClosed: ConnectionClosed_,
     ConnectionReplaced: ConnectionReplaced_,
@@ -2669,6 +3039,7 @@ export const P2pEvent = (() => {
     StreamClosed: StreamClosed_,
     EndpointError: EndpointError_,
     ReachabilityChanged: ReachabilityChanged_,
+    ListenAddressesChanged: ListenAddressesChanged_,
     PublicAddressesChanged: PublicAddressesChanged_,
     RelayReserved: RelayReserved_,
     RelayReservationLost: RelayReservationLost_,
@@ -2714,45 +3085,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),
@@ -2760,39 +3137,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),
@@ -2800,39 +3177,43 @@ 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.ListenAddressesChanged({
+            addrs: FfiConverterSequenceString.readFromCursor(c)
+          });
+        case 20:
           return new P2pEvent.PublicAddressesChanged({
             addrs: FfiConverterSequenceString.readFromCursor(c)
           });
-        case 19:
+        case 21:
           return new P2pEvent.RelayReserved({
             relayPeerId: FfiConverterString.readFromCursor(c),
             expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c)
           });
-        case 20:
+        case 22:
           return new P2pEvent.RelayReservationLost({
             relayPeerId: FfiConverterString.readFromCursor(c)
           });
-        case 21:
+        case 23:
           return new P2pEvent.PathEstablished({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             path: FfiConverterTypePathKind.readFromCursor(c)
           });
-        case 22:
+        case 24:
           return new P2pEvent.InboundPathEstablished({
             peerId: FfiConverterString.readFromCursor(c),
             path: FfiConverterTypePathKind.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 23:
+        case 25:
           return new P2pEvent.PathUpgraded({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c),
@@ -2841,31 +3222,31 @@ const FfiConverterTypeP2pEvent = (() => {
             oldConnId: FfiConverterUInt64.readFromCursor(c),
             newConnId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 24:
+        case 26:
           return new P2pEvent.HolePunchFailed({
             connectId: FfiConverterUInt64.readFromCursor(c),
             attempt: FfiConverterUInt32.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 25:
+        case 27:
           return new P2pEvent.ConnectFailed({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c),
             kind: FfiConverterTypeNatErrorKind.readFromCursor(c),
             detail: FfiConverterString.readFromCursor(c)
           });
-        case 26:
+        case 28:
           return new P2pEvent.ConnectCancelled({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c)
           });
-        case 27:
+        case 29:
           return new P2pEvent.InboundDirectUpgrade({
             peerId: FfiConverterString.readFromCursor(c),
             oldConnId: FfiConverterUInt64.readFromCursor(c),
             newConnId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 28:
+        case 30:
           return new P2pEvent.Message({
             fromPeerId: FfiConverterString.readFromCursor(c),
             topics: FfiConverterSequenceString.readFromCursor(c),
@@ -2873,55 +3254,55 @@ const FfiConverterTypeP2pEvent = (() => {
             seqno: FfiConverterArrayBuffer.readFromCursor(c),
             signed: FfiConverterBool.readFromCursor(c)
           });
-        case 29:
+        case 31:
           return new P2pEvent.PeerSubscribed({
             peerId: FfiConverterString.readFromCursor(c),
             topic: FfiConverterString.readFromCursor(c)
           });
-        case 30:
+        case 32:
           return new P2pEvent.PeerUnsubscribed({
             peerId: FfiConverterString.readFromCursor(c),
             topic: FfiConverterString.readFromCursor(c)
           });
-        case 31:
+        case 33:
           return new P2pEvent.GossipsubOutboundFailure({
             peerId: FfiConverterString.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 32:
+        case 34:
           return new P2pEvent.GossipsubProtocolViolation({
             peerId: FfiConverterString.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 33:
+        case 35:
           return new P2pEvent.PeerDiscovered({
             peerId: FfiConverterString.readFromCursor(c),
             addrs: FfiConverterSequenceString.readFromCursor(c),
             source: FfiConverterTypeDiscoverySource.readFromCursor(c)
           });
-        case 34:
+        case 36:
           return new P2pEvent.PeerUpdated({
             peerId: FfiConverterString.readFromCursor(c),
             addrs: FfiConverterSequenceString.readFromCursor(c),
             source: FfiConverterTypeDiscoverySource.readFromCursor(c)
           });
-        case 35:
+        case 37:
           return new P2pEvent.PeerExpired({
             peerId: FfiConverterString.readFromCursor(c)
           });
-        case 36:
+        case 38:
           return new P2pEvent.DiscoveryDialFailed({
             peerId: FfiConverterString.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 37:
+        case 39:
           return new P2pEvent.MdnsFailed({
             kind: FfiConverterTypeMdnsFailureKind.readFromCursor(c),
             detail: FfiConverterString.readFromCursor(c)
           });
-        case 38:
+        case 40:
           return new P2pEvent.MdnsRecovered();
-        case 39:
+        case 41:
           return new P2pEvent.DiscoveryProtocolViolation({
             peerId: FfiConverterOptionalString.readFromCursor(c),
             source: FfiConverterTypeDiscoverySource.readFromCursor(c),
@@ -2951,25 +3332,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);
@@ -2978,7 +3368,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);
@@ -2987,7 +3377,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);
@@ -2996,7 +3386,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);
@@ -3005,7 +3395,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);
@@ -3013,7 +3403,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);
@@ -3024,7 +3414,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);
@@ -3034,7 +3424,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);
@@ -3043,7 +3433,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);
@@ -3053,7 +3443,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);
@@ -3062,7 +3452,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);
@@ -3071,7 +3461,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);
@@ -3082,23 +3472,30 @@ 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);
             FfiConverterSequenceString.writeIntoCursor(inner.confirmedAddrs, c);
             return;
           }
+        case P2pEvent_Tags.ListenAddressesChanged:
+          {
+            c.writeI32(19);
+            const inner = value.inner;
+            FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
+            return;
+          }
         case P2pEvent_Tags.PublicAddressesChanged:
           {
-            c.writeI32(18);
+            c.writeI32(20);
             const inner = value.inner;
             FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
             return;
           }
         case P2pEvent_Tags.RelayReserved:
           {
-            c.writeI32(19);
+            c.writeI32(21);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
             FfiConverterOptionalUInt64.writeIntoCursor(inner.expiresUnixSecs, c);
@@ -3106,14 +3503,14 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.RelayReservationLost:
           {
-            c.writeI32(20);
+            c.writeI32(22);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
             return;
           }
         case P2pEvent_Tags.PathEstablished:
           {
-            c.writeI32(21);
+            c.writeI32(23);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -3123,7 +3520,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.InboundPathEstablished:
           {
-            c.writeI32(22);
+            c.writeI32(24);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
@@ -3132,7 +3529,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PathUpgraded:
           {
-            c.writeI32(23);
+            c.writeI32(25);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -3144,7 +3541,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.HolePunchFailed:
           {
-            c.writeI32(24);
+            c.writeI32(26);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterUInt32.writeIntoCursor(inner.attempt, c);
@@ -3153,7 +3550,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.ConnectFailed:
           {
-            c.writeI32(25);
+            c.writeI32(27);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -3163,7 +3560,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.ConnectCancelled:
           {
-            c.writeI32(26);
+            c.writeI32(28);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -3171,7 +3568,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.InboundDirectUpgrade:
           {
-            c.writeI32(27);
+            c.writeI32(29);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.oldConnId, c);
@@ -3180,7 +3577,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.Message:
           {
-            c.writeI32(28);
+            c.writeI32(30);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.fromPeerId, c);
             FfiConverterSequenceString.writeIntoCursor(inner.topics, c);
@@ -3191,7 +3588,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerSubscribed:
           {
-            c.writeI32(29);
+            c.writeI32(31);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.topic, c);
@@ -3199,7 +3596,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerUnsubscribed:
           {
-            c.writeI32(30);
+            c.writeI32(32);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.topic, c);
@@ -3207,7 +3604,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.GossipsubOutboundFailure:
           {
-            c.writeI32(31);
+            c.writeI32(33);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.reason, c);
@@ -3215,7 +3612,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.GossipsubProtocolViolation:
           {
-            c.writeI32(32);
+            c.writeI32(34);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.reason, c);
@@ -3223,7 +3620,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerDiscovered:
           {
-            c.writeI32(33);
+            c.writeI32(35);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
@@ -3232,7 +3629,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerUpdated:
           {
-            c.writeI32(34);
+            c.writeI32(36);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
@@ -3241,14 +3638,14 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerExpired:
           {
-            c.writeI32(35);
+            c.writeI32(37);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             return;
           }
         case P2pEvent_Tags.DiscoveryDialFailed:
           {
-            c.writeI32(36);
+            c.writeI32(38);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.reason, c);
@@ -3256,7 +3653,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.MdnsFailed:
           {
-            c.writeI32(37);
+            c.writeI32(39);
             const inner = value.inner;
             FfiConverterTypeMdnsFailureKind.writeIntoCursor(inner.kind, c);
             FfiConverterString.writeIntoCursor(inner.detail, c);
@@ -3264,12 +3661,12 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.MdnsRecovered:
           {
-            c.writeI32(38);
+            c.writeI32(40);
             return;
           }
         case P2pEvent_Tags.DiscoveryProtocolViolation:
           {
-            c.writeI32(39);
+            c.writeI32(41);
             const inner = value.inner;
             FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
             FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
@@ -3301,6 +3698,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;
@@ -3315,6 +3720,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:
@@ -3439,6 +3845,13 @@ const FfiConverterTypeP2pEvent = (() => {
             size += FfiConverterSequenceString.allocationSize(inner.confirmedAddrs);
             return size;
           }
+        case P2pEvent_Tags.ListenAddressesChanged:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterSequenceString.allocationSize(inner.addrs);
+            return size;
+          }
         case P2pEvent_Tags.PublicAddressesChanged:
           {
             const inner = value.inner;
@@ -3634,15 +4047,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);
 
@@ -3658,6 +4071,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.
  *
@@ -3680,8 +4096,10 @@ function uniffiEnsureInitialized() {
 export default Object.freeze({
   initialize: uniffiEnsureInitialized,
   converters: {
+    FfiConverterTypeCloseOutcome,
     FfiConverterTypeConfigCapability,
     FfiConverterTypeConnectTarget,
+    FfiConverterTypeConnectionCloseReason,
     FfiConverterTypeConnectionInfo,
     FfiConverterTypeDiscoveryOptions,
     FfiConverterTypeDiscoverySource,
@@ -3698,7 +4116,8 @@ export default Object.freeze({
     FfiConverterTypeP2pEvent,
     FfiConverterTypePathKind,
     FfiConverterTypeReachability,
-    FfiConverterTypeRelayReservationInfo
+    FfiConverterTypeRelayReservationInfo,
+    FfiConverterTypeUnfinishedConnection
   }
 });
 //# sourceMappingURL=minip2p_ffi_core.js.map