@minip2p/react-native 0.8.3 → 0.10.0

package/src/generated/minip2p_ffi_core.ts

@@ -71,23 +71,206 @@ const stringConverter = (() => {
 })();
 const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
 
+
+// Enum: PathKind
+export enum PathKind_Tags {
+    Direct = "Direct",
+    Punched = "Punched",
+    Relayed = "Relayed"
+}
 /**
- * State snapshot of the transport connection selected for a peer.
+ * How an established connection was made; see `minip2p::Path`.
+ */
+export const PathKind = (() => {
+
+    type Direct__interface = {
+        tag: PathKind_Tags.Direct
+    };
+    /**
+     * A direct connection we dialed or accepted.
+     */
+    class Direct_ extends UniffiEnum implements Direct__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "PathKind";
+        readonly tag = PathKind_Tags.Direct;
+        constructor() {
+            super("PathKind", "Direct");
+        }
+
+        static new(): Direct_ {
+            return new Direct_();
+        }
+
+        static instanceOf(obj: any): obj is Direct_ {
+            return obj.tag === PathKind_Tags.Direct;
+        }
+
+    }
+
+    type Punched__interface = {
+        tag: PathKind_Tags.Punched
+    };
+    /**
+     * A direct connection made by a DCUtR hole punch.
+     */
+    class Punched_ extends UniffiEnum implements Punched__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "PathKind";
+        readonly tag = PathKind_Tags.Punched;
+        constructor() {
+            super("PathKind", "Punched");
+        }
+
+        static new(): Punched_ {
+            return new Punched_();
+        }
+
+        static instanceOf(obj: any): obj is Punched_ {
+            return obj.tag === PathKind_Tags.Punched;
+        }
+
+    }
+
+    type Relayed__interface = {
+        tag: PathKind_Tags.Relayed;
+        inner:
+Readonly<{relayPeerId: string}>
+    };
+    /**
+     * Traffic is carried through a relay.
+     */
+    class Relayed_ extends UniffiEnum implements Relayed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "PathKind";
+        readonly tag = PathKind_Tags.Relayed;
+        readonly inner:
+Readonly<{relayPeerId: string}>;
+        constructor(
+inner: {relayPeerId: string }) {
+            super("PathKind", "Relayed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {relayPeerId: string }): Relayed_ {
+            return new Relayed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Relayed_ {
+            return obj.tag === PathKind_Tags.Relayed;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is PathKind {
+        return obj[uniffiTypeNameSymbol] === "PathKind";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Direct: Direct_,
+  Punched: Punched_,
+  Relayed: Relayed_
+    });
+
+})();
+/**
+ * How an established connection was made; see `minip2p::Path`.
+ */
+export type PathKind = InstanceType<
+    typeof PathKind['Direct' | 'Punched' | 'Relayed']
+>;
+
+// FfiConverter for enum PathKind
+const FfiConverterTypePathKind = (() => {
+    type TypeName = PathKind;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            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: TypeName, c: Cursor): void {
+            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: TypeName): number {
+            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`.
  */
 export type ConnectionInfo = {
+    /**
+     * The peer on the other end.
+     */
+    peerId: string,
     /**
      * Endpoint-local transport connection id.
      */
     connId: bigint,
     /**
-     * Remote transport address, when recorded.
+     * Remote transport address the transport reported; a circuit reports
+     * `/p2p/<relay>/p2p-circuit`.
+     */
+    remoteAddr: string,
+    /**
+     * How the connection was made.
      */
-    remoteAddr?: string,
+    path: PathKind,
     /**
      * Protocols this connection advertised through Identify, once it is
-     * ready (`PeerReady` for this `conn_id`); `None` until then. Readiness,
-     * connection and protocols come from one snapshot, so a ready wait can
-     * trust them together.
+     * ready (`PeerReady` for this `conn_id`); `None` until then, distinct
+     * from an empty list. Readiness, connection and protocols come from one
+     * snapshot, so a ready wait can trust them together.
      */
     readyProtocols?: Array<string>
 }
@@ -113,19 +296,25 @@ const FfiConverterTypeConnectionInfo = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
         readFromCursor(c: Cursor): TypeName {
             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: TypeName, c: Cursor): void {
+            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: TypeName): number {
-            return FfiConverterUInt64.allocationSize(value.connId) +
-             FfiConverterOptionalString.allocationSize(value.remoteAddr) +
+            return FfiConverterString.allocationSize(value.peerId) +
+             FfiConverterUInt64.allocationSize(value.connId) +
+             FfiConverterString.allocationSize(value.remoteAddr) +
+             FfiConverterTypePathKind.allocationSize(value.path) +
              FfiConverterOptionalSequenceString.allocationSize(value.readyProtocols);
 
         }
@@ -662,6 +851,164 @@ const FfiConverterTypeRelayReservationInfo = (() => {
     return new FFIConverter();
 })();
 
+/**
+ * A connection still tracked when the closing drain ended.
+ */
+export type UnfinishedConnection = {
+    /**
+     * Endpoint-local transport connection id.
+     */
+    connId: bigint,
+    /**
+     * Remote peer; `None` for an inbound handshake that had not identified
+     * one yet.
+     */
+    peerId?: string
+}
+
+/**
+ * Generated factory for {@link UnfinishedConnection} record objects.
+ */
+export const UnfinishedConnection = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<UnfinishedConnection, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<UnfinishedConnection>,
+    });
+})();
+
+const FfiConverterTypeUnfinishedConnection = (() => {
+    type TypeName = UnfinishedConnection;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                connId: FfiConverterUInt64.readFromCursor(c),
+                peerId: FfiConverterOptionalString.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterUInt64.writeIntoCursor(value.connId, c);
+            FfiConverterOptionalString.writeIntoCursor(value.peerId, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterUInt64.allocationSize(value.connId) +
+             FfiConverterOptionalString.allocationSize(value.peerId);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * How the driver's closing drain ended; see [`P2pEvent::EndpointClosed`].
+ */
+export enum CloseOutcome {
+    /**
+     * Every tracked connection finished its teardown in time.
+     */
+    Drained,
+    /**
+     * The stop deadline passed with connections still tracked.
+     */
+    DeadlineExpired,
+    /**
+     * Driving the transports failed and ended the drain early, or the
+     * driver panicked and dropped the endpoint without a drain.
+     */
+    Failed
+}
+
+const FfiConverterTypeCloseOutcome = (() => {
+    type TypeName = CloseOutcome;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            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: TypeName, c: Cursor): void {
+            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: TypeName): number {
+            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 enum ConfigCapability {
+    /**
+     * Gossipsub settings.
+     */
+    Gossipsub,
+    /**
+     * mDNS settings.
+     */
+    Mdns,
+    /**
+     * Signed discovery or peer-book settings.
+     */
+    Discovery,
+    /**
+     * QUIC or TCP transport settings (limits, TLS, the TCP namespace).
+     */
+    Transport,
+    /**
+     * The endpoint's own options: listen addresses, protocols, NAT and
+     * relay policy, auto-dial.
+     */
+    Options
+}
+
+const FfiConverterTypeConfigCapability = (() => {
+    type TypeName = ConfigCapability;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            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: TypeName, c: Cursor): void {
+            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: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
 
 // Enum: ConnectTarget
 export enum ConnectTarget_Tags {
@@ -676,139 +1023,399 @@ export enum ConnectTarget_Tags {
  */
 export const ConnectTarget = (() => {
 
-    type Peer__interface = {
-        tag: ConnectTarget_Tags.Peer;
+    type Peer__interface = {
+        tag: ConnectTarget_Tags.Peer;
+        inner:
+Readonly<{peerId: string}>
+    };
+    /**
+     * Peer ID only: the endpoint applies its discovery-book and relay
+     * policy.
+     */
+    class Peer_ extends UniffiEnum implements Peer__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ConnectTarget";
+        readonly tag = ConnectTarget_Tags.Peer;
+        readonly inner:
+Readonly<{peerId: string}>;
+        constructor(
+inner: {peerId: string }) {
+            super("ConnectTarget", "Peer");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {peerId: string }): Peer_ {
+            return new Peer_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Peer_ {
+            return obj.tag === ConnectTarget_Tags.Peer;
+        }
+
+    }
+
+    type Addresses__interface = {
+        tag: ConnectTarget_Tags.Addresses;
+        inner:
+Readonly<{addresses: Array<string>}>
+    };
+    /**
+     * One or more complete direct peer addresses that all name the same
+     * peer. One address is the single-address form.
+     */
+    class Addresses_ extends UniffiEnum implements Addresses__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ConnectTarget";
+        readonly tag = ConnectTarget_Tags.Addresses;
+        readonly inner:
+Readonly<{addresses: Array<string>}>;
+        constructor(
+inner: {addresses: Array<string> }) {
+            super("ConnectTarget", "Addresses");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {addresses: Array<string> }): Addresses_ {
+            return new Addresses_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Addresses_ {
+            return obj.tag === ConnectTarget_Tags.Addresses;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is ConnectTarget {
+        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.
+ */
+export type ConnectTarget = InstanceType<
+    typeof ConnectTarget['Peer' | 'Addresses']
+>;
+
+// FfiConverter for enum ConnectTarget
+const FfiConverterTypeConnectTarget = (() => {
+    type TypeName = ConnectTarget;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            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: TypeName, c: Cursor): void {
+            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: TypeName): number {
+            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 enum ConnectionCloseReason_Tags {
+    Local = "Local",
+    Remote = "Remote",
+    TimedOut = "TimedOut",
+    Stalled = "Stalled",
+    Error = "Error"
+}
+/**
+ * Why one connection ended; see `minip2p::ConnectionCloseReason`.
+ */
+export const ConnectionCloseReason = (() => {
+
+    type Local__interface = {
+        tag: ConnectionCloseReason_Tags.Local
+    };
+    /**
+     * We closed it.
+     */
+    class Local_ extends UniffiEnum implements Local__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+        readonly tag = ConnectionCloseReason_Tags.Local;
+        constructor() {
+            super("ConnectionCloseReason", "Local");
+        }
+
+        static new(): Local_ {
+            return new Local_();
+        }
+
+        static instanceOf(obj: any): obj is Local_ {
+            return obj.tag === ConnectionCloseReason_Tags.Local;
+        }
+
+    }
+
+    type Remote__interface = {
+        tag: ConnectionCloseReason_Tags.Remote;
         inner:
-Readonly<{peerId: string}>
+Readonly<{code: bigint}>
     };
     /**
-     * Peer ID only: the endpoint applies its discovery-book and relay
-     * policy.
+     * The peer closed it with `code`: its QUIC CONNECTION_CLOSE code, or
+     * its Yamux `GoAway` code on TCP and relay circuits.
      */
-    class Peer_ extends UniffiEnum implements Peer__interface {
+    class Remote_ extends UniffiEnum implements Remote__interface {
         /**
          * @private
          * This field is private and should not be used, use `tag` instead.
          */
-        readonly [uniffiTypeNameSymbol] = "ConnectTarget";
-        readonly tag = ConnectTarget_Tags.Peer;
+        readonly [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+        readonly tag = ConnectionCloseReason_Tags.Remote;
         readonly inner:
-Readonly<{peerId: string}>;
+Readonly<{code: bigint}>;
         constructor(
-inner: {peerId: string }) {
-            super("ConnectTarget", "Peer");
+inner: {code: bigint }) {
+            super("ConnectionCloseReason", "Remote");
 
             this.inner = Object.freeze(inner);
         }
         static new(
-inner: {peerId: string }): Peer_ {
-            return new Peer_(inner);
+inner: {code: bigint }): Remote_ {
+            return new Remote_(inner);
         }
 
-        static instanceOf(obj: any): obj is Peer_ {
-            return obj.tag === ConnectTarget_Tags.Peer;
+        static instanceOf(obj: any): obj is Remote_ {
+            return obj.tag === ConnectionCloseReason_Tags.Remote;
         }
 
     }
 
-    type Addresses__interface = {
-        tag: ConnectTarget_Tags.Addresses;
+    type TimedOut__interface = {
+        tag: ConnectionCloseReason_Tags.TimedOut
+    };
+    /**
+     * The peer went silent (an idle, keepalive or handshake timeout).
+     */
+    class TimedOut_ extends UniffiEnum implements TimedOut__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+        readonly tag = ConnectionCloseReason_Tags.TimedOut;
+        constructor() {
+            super("ConnectionCloseReason", "TimedOut");
+        }
+
+        static new(): TimedOut_ {
+            return new TimedOut_();
+        }
+
+        static instanceOf(obj: any): obj is TimedOut_ {
+            return obj.tag === ConnectionCloseReason_Tags.TimedOut;
+        }
+
+    }
+
+    type Stalled__interface = {
+        tag: ConnectionCloseReason_Tags.Stalled
+    };
+    /**
+     * The peer stopped reading (a TCP send stall).
+     */
+    class Stalled_ extends UniffiEnum implements Stalled__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+        readonly tag = ConnectionCloseReason_Tags.Stalled;
+        constructor() {
+            super("ConnectionCloseReason", "Stalled");
+        }
+
+        static new(): Stalled_ {
+            return new Stalled_();
+        }
+
+        static instanceOf(obj: any): obj is Stalled_ {
+            return obj.tag === ConnectionCloseReason_Tags.Stalled;
+        }
+
+    }
+
+    type Error__interface = {
+        tag: ConnectionCloseReason_Tags.Error;
         inner:
-Readonly<{addresses: Array<string>}>
+Readonly<{message: string}>
     };
     /**
-     * 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 implements Addresses__interface {
+    class Error_ extends UniffiEnum implements Error__interface {
         /**
          * @private
          * This field is private and should not be used, use `tag` instead.
          */
-        readonly [uniffiTypeNameSymbol] = "ConnectTarget";
-        readonly tag = ConnectTarget_Tags.Addresses;
+        readonly [uniffiTypeNameSymbol] = "ConnectionCloseReason";
+        readonly tag = ConnectionCloseReason_Tags.Error;
         readonly inner:
-Readonly<{addresses: Array<string>}>;
+Readonly<{message: string}>;
         constructor(
-inner: {addresses: Array<string> }) {
-            super("ConnectTarget", "Addresses");
+inner: {message: string }) {
+            super("ConnectionCloseReason", "Error");
 
             this.inner = Object.freeze(inner);
         }
         static new(
-inner: {addresses: Array<string> }): Addresses_ {
-            return new Addresses_(inner);
+inner: {message: string }): Error_ {
+            return new Error_(inner);
         }
 
-        static instanceOf(obj: any): obj is Addresses_ {
-            return obj.tag === ConnectTarget_Tags.Addresses;
+        static instanceOf(obj: any): obj is Error_ {
+            return obj.tag === ConnectionCloseReason_Tags.Error;
         }
 
     }
 
-    function instanceOf(obj: any): obj is ConnectTarget {
-        return obj[uniffiTypeNameSymbol] === "ConnectTarget";
+    function instanceOf(obj: any): obj is ConnectionCloseReason {
+        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`.
  */
-export type ConnectTarget = InstanceType<
-    typeof ConnectTarget['Peer' | 'Addresses']
+export type ConnectionCloseReason = InstanceType<
+    typeof ConnectionCloseReason['Local' | 'Remote' | 'TimedOut' | 'Stalled' | 'Error']
 >;
 
-// FfiConverter for enum ConnectTarget
-const FfiConverterTypeConnectTarget = (() => {
-    type TypeName = ConnectTarget;
+// FfiConverter for enum ConnectionCloseReason
+const FfiConverterTypeConnectionCloseReason = (() => {
+    type TypeName = ConnectionCloseReason;
     class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
         readFromCursor(c: Cursor): TypeName {
             switch (c.readI32()) {
-                case 1: return new ConnectTarget.Peer({peerId: FfiConverterString.readFromCursor(c) });
-                case 2: return new ConnectTarget.Addresses({addresses: FfiConverterSequenceString.readFromCursor(c) });
+                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: TypeName, c: Cursor): void {
             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: TypeName): number {
             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: throw new UniffiInternalError.UnexpectedEnumCase();
@@ -1062,10 +1669,11 @@ export const FfiError = (() => {
     type InvalidConfig__interface = {
         tag: FfiError_Tags.InvalidConfig;
         inner:
-Readonly<{detail: string}>
+Readonly<{capability: ConfigCapability; detail: string}>
     };
     /**
-     * Endpoint configuration was internally inconsistent.
+     * Endpoint configuration was invalid; `capability` names the part of
+     * it that was.
      */
     class InvalidConfig_ extends UniffiError implements InvalidConfig__interface {
         /**
@@ -1075,15 +1683,15 @@ Readonly<{detail: string}>
         readonly [uniffiTypeNameSymbol] = "FfiError";
         readonly tag = FfiError_Tags.InvalidConfig;
         readonly inner:
-Readonly<{detail: string}>;
+Readonly<{capability: ConfigCapability; detail: string}>;
         constructor(
-inner: {detail: string }) {
+inner: {capability: ConfigCapability; detail: string }) {
             super("FfiError", "InvalidConfig");
 
             this.inner = Object.freeze(inner);
         }
         static new(
-inner: {detail: string }): InvalidConfig_ {
+inner: {capability: ConfigCapability; detail: string }): InvalidConfig_ {
             return new InvalidConfig_(inner);
         }
 
@@ -1095,7 +1703,7 @@ inner: {detail: string }): InvalidConfig_ {
         }
 
         static getInner(obj: InvalidConfig_):
-Readonly<{detail: string}> {
+Readonly<{capability: ConfigCapability; detail: string}> {
             return obj.inner;
         }
 
@@ -1377,7 +1985,8 @@ Readonly<{detail: string}> {
 Readonly<{detail: string}>
     };
     /**
-     * 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 implements Transport__interface {
         /**
@@ -1534,7 +2143,7 @@ const FfiConverterTypeFfiError = (() => {
             switch (c.readI32()) {
                 case 1: return new FfiError.AlreadyStarted();
                 case 2: return new FfiError.Stopped();
-                case 3: return new FfiError.InvalidConfig({detail: FfiConverterString.readFromCursor(c) });
+                case 3: return new FfiError.InvalidConfig({capability: FfiConverterTypeConfigCapability.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
                 case 4: return new FfiError.InvalidKey({detail: FfiConverterString.readFromCursor(c) });
                 case 5: return new FfiError.InvalidPeerId({detail: FfiConverterString.readFromCursor(c) });
                 case 6: return new FfiError.InvalidAddress({detail: FfiConverterString.readFromCursor(c) });
@@ -1561,6 +2170,7 @@ const FfiConverterTypeFfiError = (() => {
                 case FfiError_Tags.InvalidConfig: {
                     c.writeI32(3);
                     const inner = value.inner;
+                    FfiConverterTypeConfigCapability.writeIntoCursor(inner.capability, c);
                     FfiConverterString.writeIntoCursor(inner.detail, c);
                     return;
                 }
@@ -1636,6 +2246,7 @@ const FfiConverterTypeFfiError = (() => {
                 case FfiError_Tags.InvalidConfig: {
                     const inner = value.inner;
                     let size = 4;
+                    size += FfiConverterTypeConfigCapability.allocationSize(inner.capability);
                     size += FfiConverterString.allocationSize(inner.detail);
                     return size;
                 }
@@ -1701,94 +2312,64 @@ const FfiConverterTypeFfiError = (() => {
 })();
 
 /**
- * Category of a failed NAT connection attempt.
+ * Category of an mDNS failure.
  */
-export enum NatErrorKind {
-    /**
-     * No usable direct or relayed path exists.
-     */
-    NoPathAvailable,
+export enum MdnsFailureKind {
     /**
-     * The connection attempt timed out.
+     * The platform cannot provide mDNS sockets.
      */
-    Timeout,
+    Unsupported,
     /**
-     * A transport dial failed.
+     * An interface has no usable address.
      */
-    DialFailed,
+    NoInterfaceAddress,
     /**
-     * A traversal protocol exchange failed.
+     * A send named an interface that has gone away.
      */
-    Protocol,
+    UnknownInterface,
     /**
-     * A relay refused the circuit.
+     * A goodbye could not be sent before shutdown gave up on a full send
+     * buffer.
      */
-    RelayRefused
-}
-
-const FfiConverterTypeNatErrorKind = (() => {
-    type TypeName = NatErrorKind;
-    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
-        readFromCursor(c: Cursor): TypeName {
-            switch (c.readI32()) {
-                case 1: return NatErrorKind.NoPathAvailable;
-                case 2: return NatErrorKind.Timeout;
-                case 3: return NatErrorKind.DialFailed;
-                case 4: return NatErrorKind.Protocol;
-                case 5: return NatErrorKind.RelayRefused;
-                default: throw new UniffiInternalError.UnexpectedEnumCase();
-            }
-        }
-        writeIntoCursor(value: TypeName, c: Cursor): void {
-            switch (value) {
-                case NatErrorKind.NoPathAvailable: return c.writeI32(1);
-                case NatErrorKind.Timeout: return c.writeI32(2);
-                case NatErrorKind.DialFailed: return c.writeI32(3);
-                case NatErrorKind.Protocol: return c.writeI32(4);
-                case NatErrorKind.RelayRefused: return c.writeI32(5);
-            }
-        }
-        allocationSize(value: TypeName): number {
-            return 4;
-        }
-    }
-    return new FFIConverter();
-})();
-
-/**
- * Coarse local reachability state.
- */
-export enum Reachability {
+    Congested,
     /**
-     * Not enough evidence is available.
+     * A datagram is larger than the carrier can ever send.
      */
-    Unknown,
+    Oversized,
     /**
-     * The endpoint is directly reachable.
+     * The interface id space is exhausted.
      */
-    Public,
+    InterfaceIdsExhausted,
     /**
-     * The endpoint needs traversal or relay assistance.
+     * Platform I/O failed.
      */
-    Private
+    Io
 }
 
-const FfiConverterTypeReachability = (() => {
-    type TypeName = Reachability;
+const FfiConverterTypeMdnsFailureKind = (() => {
+    type TypeName = MdnsFailureKind;
     class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
         readFromCursor(c: Cursor): TypeName {
             switch (c.readI32()) {
-                case 1: return Reachability.Unknown;
-                case 2: return Reachability.Public;
-                case 3: return Reachability.Private;
+                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: TypeName, c: Cursor): void {
             switch (value) {
-                case Reachability.Unknown: return c.writeI32(1);
-                case Reachability.Public: return c.writeI32(2);
-                case Reachability.Private: return c.writeI32(3);
+                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: TypeName): number {
@@ -1798,174 +2379,99 @@ const FfiConverterTypeReachability = (() => {
     return new FFIConverter();
 })();
 
-
-// Enum: PathKind
-export enum PathKind_Tags {
-    DirectDialed = "DirectDialed",
-    DirectPunched = "DirectPunched",
-    Relayed = "Relayed"
-}
 /**
- * Kind of usable connection path.
+ * Category of a failed NAT connection attempt.
  */
-export const PathKind = (() => {
-
-    type DirectDialed__interface = {
-        tag: PathKind_Tags.DirectDialed
-    };
+export enum NatErrorKind {
     /**
-     * A known address was dialed directly.
+     * No usable direct or relayed path exists.
      */
-    class DirectDialed_ extends UniffiEnum implements DirectDialed__interface {
-        /**
-         * @private
-         * This field is private and should not be used, use `tag` instead.
-         */
-        readonly [uniffiTypeNameSymbol] = "PathKind";
-        readonly tag = PathKind_Tags.DirectDialed;
-        constructor() {
-            super("PathKind", "DirectDialed");
-        }
-
-        static new(): DirectDialed_ {
-            return new DirectDialed_();
-        }
-
-        static instanceOf(obj: any): obj is DirectDialed_ {
-            return obj.tag === PathKind_Tags.DirectDialed;
-        }
-
-    }
-
-    type DirectPunched__interface = {
-        tag: PathKind_Tags.DirectPunched
-    };
+    NoPathAvailable,
     /**
-     * A direct path was established by hole punching.
+     * The connection attempt timed out.
      */
-    class DirectPunched_ extends UniffiEnum implements DirectPunched__interface {
-        /**
-         * @private
-         * This field is private and should not be used, use `tag` instead.
-         */
-        readonly [uniffiTypeNameSymbol] = "PathKind";
-        readonly tag = PathKind_Tags.DirectPunched;
-        constructor() {
-            super("PathKind", "DirectPunched");
-        }
-
-        static new(): DirectPunched_ {
-            return new DirectPunched_();
-        }
-
-        static instanceOf(obj: any): obj is DirectPunched_ {
-            return obj.tag === PathKind_Tags.DirectPunched;
-        }
-
-    }
-
-    type Relayed__interface = {
-        tag: PathKind_Tags.Relayed;
-        inner:
-Readonly<{relayPeerId: string}>
-    };
+    Timeout,
     /**
-     * Traffic is carried through a relay.
+     * A transport dial failed.
      */
-    class Relayed_ extends UniffiEnum implements Relayed__interface {
-        /**
-         * @private
-         * This field is private and should not be used, use `tag` instead.
-         */
-        readonly [uniffiTypeNameSymbol] = "PathKind";
-        readonly tag = PathKind_Tags.Relayed;
-        readonly inner:
-Readonly<{relayPeerId: string}>;
-        constructor(
-inner: {relayPeerId: string }) {
-            super("PathKind", "Relayed");
+    DialFailed,
+    /**
+     * A traversal protocol exchange failed.
+     */
+    Protocol,
+    /**
+     * A relay refused the circuit.
+     */
+    RelayRefused
+}
 
-            this.inner = Object.freeze(inner);
+const FfiConverterTypeNatErrorKind = (() => {
+    type TypeName = NatErrorKind;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return NatErrorKind.NoPathAvailable;
+                case 2: return NatErrorKind.Timeout;
+                case 3: return NatErrorKind.DialFailed;
+                case 4: return NatErrorKind.Protocol;
+                case 5: return NatErrorKind.RelayRefused;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
         }
-        static new(
-inner: {relayPeerId: string }): Relayed_ {
-            return new Relayed_(inner);
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case NatErrorKind.NoPathAvailable: return c.writeI32(1);
+                case NatErrorKind.Timeout: return c.writeI32(2);
+                case NatErrorKind.DialFailed: return c.writeI32(3);
+                case NatErrorKind.Protocol: return c.writeI32(4);
+                case NatErrorKind.RelayRefused: return c.writeI32(5);
+            }
         }
-
-        static instanceOf(obj: any): obj is Relayed_ {
-            return obj.tag === PathKind_Tags.Relayed;
+        allocationSize(value: TypeName): number {
+            return 4;
         }
-
-    }
-
-    function instanceOf(obj: any): obj is PathKind {
-        return obj[uniffiTypeNameSymbol] === "PathKind";
     }
-
-    return Object.freeze({
-        instanceOf,
-  DirectDialed: DirectDialed_,
-  DirectPunched: DirectPunched_,
-  Relayed: Relayed_
-    });
-
+    return new FFIConverter();
 })();
+
 /**
- * Kind of usable connection path.
+ * Coarse local reachability state.
  */
-export type PathKind = InstanceType<
-    typeof PathKind['DirectDialed' | 'DirectPunched' | 'Relayed']
->;
+export enum Reachability {
+    /**
+     * Not enough evidence is available.
+     */
+    Unknown,
+    /**
+     * The endpoint is directly reachable.
+     */
+    Public,
+    /**
+     * The endpoint needs traversal or relay assistance.
+     */
+    Private
+}
 
-// FfiConverter for enum PathKind
-const FfiConverterTypePathKind = (() => {
-    type TypeName = PathKind;
+const FfiConverterTypeReachability = (() => {
+    type TypeName = Reachability;
     class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
         readFromCursor(c: Cursor): TypeName {
             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) });
+                case 1: return Reachability.Unknown;
+                case 2: return Reachability.Public;
+                case 3: return Reachability.Private;
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
         writeIntoCursor(value: TypeName, c: Cursor): void {
-            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: TypeName): number {
-            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();
@@ -1976,6 +2482,7 @@ const FfiConverterTypePathKind = (() => {
 export enum P2pEvent_Tags {
     EventsDropped = "EventsDropped",
     DriverFailed = "DriverFailed",
+    EndpointClosed = "EndpointClosed",
     ConnectionEstablished = "ConnectionEstablished",
     ConnectionClosed = "ConnectionClosed",
     ConnectionReplaced = "ConnectionReplaced",
@@ -2010,6 +2517,8 @@ export enum P2pEvent_Tags {
     PeerUpdated = "PeerUpdated",
     PeerExpired = "PeerExpired",
     DiscoveryDialFailed = "DiscoveryDialFailed",
+    MdnsFailed = "MdnsFailed",
+    MdnsRecovered = "MdnsRecovered",
     DiscoveryProtocolViolation = "DiscoveryProtocolViolation"
 }
 /**
@@ -2085,6 +2594,42 @@ inner: {kind: DriverFailureKind; detail: string }): DriverFailed_ {
 
     }
 
+    type EndpointClosed__interface = {
+        tag: P2pEvent_Tags.EndpointClosed;
+        inner:
+Readonly<{outcome: CloseOutcome; unfinished: Array<UnfinishedConnection>}>
+    };
+    /**
+     * 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 implements EndpointClosed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.EndpointClosed;
+        readonly inner:
+Readonly<{outcome: CloseOutcome; unfinished: Array<UnfinishedConnection>}>;
+        constructor(
+inner: {outcome: CloseOutcome; unfinished: Array<UnfinishedConnection> }) {
+            super("P2pEvent", "EndpointClosed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {outcome: CloseOutcome; unfinished: Array<UnfinishedConnection> }): EndpointClosed_ {
+            return new EndpointClosed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is EndpointClosed_ {
+            return obj.tag === P2pEvent_Tags.EndpointClosed;
+        }
+
+    }
+
     type ConnectionEstablished__interface = {
         tag: P2pEvent_Tags.ConnectionEstablished;
         inner:
@@ -2122,7 +2667,7 @@ inner: {peerId: string; connId: bigint }): ConnectionEstablished_ {
     type ConnectionClosed__interface = {
         tag: P2pEvent_Tags.ConnectionClosed;
         inner:
-Readonly<{peerId: string; connId: bigint}>
+Readonly<{peerId: string; connId: bigint; reason: ConnectionCloseReason}>
     };
     /**
      * The peer's last connection closed; the peer is now disconnected.
@@ -2135,15 +2680,15 @@ Readonly<{peerId: string; connId: bigint}>
         readonly [uniffiTypeNameSymbol] = "P2pEvent";
         readonly tag = P2pEvent_Tags.ConnectionClosed;
         readonly inner:
-Readonly<{peerId: string; connId: bigint}>;
+Readonly<{peerId: string; connId: bigint; reason: ConnectionCloseReason}>;
         constructor(
-inner: {peerId: string; connId: bigint }) {
+inner: {peerId: string; connId: bigint; reason: ConnectionCloseReason }) {
             super("P2pEvent", "ConnectionClosed");
 
             this.inner = Object.freeze(inner);
         }
         static new(
-inner: {peerId: string; connId: bigint }): ConnectionClosed_ {
+inner: {peerId: string; connId: bigint; reason: ConnectionCloseReason }): ConnectionClosed_ {
             return new ConnectionClosed_(inner);
         }
 
@@ -3254,6 +3799,70 @@ inner: {peerId: string; reason: string }): DiscoveryDialFailed_ {
 
     }
 
+    type MdnsFailed__interface = {
+        tag: P2pEvent_Tags.MdnsFailed;
+        inner:
+Readonly<{kind: MdnsFailureKind; detail: string}>
+    };
+    /**
+     * 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 implements MdnsFailed__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.MdnsFailed;
+        readonly inner:
+Readonly<{kind: MdnsFailureKind; detail: string}>;
+        constructor(
+inner: {kind: MdnsFailureKind; detail: string }) {
+            super("P2pEvent", "MdnsFailed");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {kind: MdnsFailureKind; detail: string }): MdnsFailed_ {
+            return new MdnsFailed_(inner);
+        }
+
+        static instanceOf(obj: any): obj is MdnsFailed_ {
+            return obj.tag === P2pEvent_Tags.MdnsFailed;
+        }
+
+    }
+
+    type MdnsRecovered__interface = {
+        tag: P2pEvent_Tags.MdnsRecovered
+    };
+    /**
+     * mDNS recovered from its last `MdnsFailed`.
+     */
+    class MdnsRecovered_ extends UniffiEnum implements MdnsRecovered__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.MdnsRecovered;
+        constructor() {
+            super("P2pEvent", "MdnsRecovered");
+        }
+
+        static new(): MdnsRecovered_ {
+            return new MdnsRecovered_();
+        }
+
+        static instanceOf(obj: any): obj is MdnsRecovered_ {
+            return obj.tag === P2pEvent_Tags.MdnsRecovered;
+        }
+
+    }
+
     type DiscoveryProtocolViolation__interface = {
         tag: P2pEvent_Tags.DiscoveryProtocolViolation;
         inner:
@@ -3296,6 +3905,7 @@ inner: {peerId?: string; source: DiscoverySource; reason: string; suppressed: nu
         instanceOf,
   EventsDropped: EventsDropped_,
   DriverFailed: DriverFailed_,
+  EndpointClosed: EndpointClosed_,
   ConnectionEstablished: ConnectionEstablished_,
   ConnectionClosed: ConnectionClosed_,
   ConnectionReplaced: ConnectionReplaced_,
@@ -3330,6 +3940,8 @@ inner: {peerId?: string; source: DiscoverySource; reason: string; suppressed: nu
   PeerUpdated: PeerUpdated_,
   PeerExpired: PeerExpired_,
   DiscoveryDialFailed: DiscoveryDialFailed_,
+  MdnsFailed: MdnsFailed_,
+  MdnsRecovered: MdnsRecovered_,
   DiscoveryProtocolViolation: DiscoveryProtocolViolation_
     });
 
@@ -3338,7 +3950,7 @@ inner: {peerId?: string; source: DiscoverySource; reason: string; suppressed: nu
  * Event delivered by the native endpoint driver.
  */
 export type P2pEvent = InstanceType<
-    typeof P2pEvent['EventsDropped' | 'DriverFailed' | 'ConnectionEstablished' | 'ConnectionClosed' | 'ConnectionReplaced' | 'PeerReady' | 'IdentifyReceived' | 'PingRttMeasured' | 'PingTimeout' | 'StreamReady' | 'StreamData' | 'StreamWriteAccepted' | 'StreamWriteStopped' | 'StreamRemoteWriteClosed' | 'StreamClosed' | 'EndpointError' | 'ReachabilityChanged' | 'PublicAddressesChanged' | 'RelayReserved' | 'RelayReservationLost' | 'PathEstablished' | 'InboundPathEstablished' | 'PathUpgraded' | 'HolePunchFailed' | 'ConnectFailed' | 'ConnectCancelled' | 'InboundDirectUpgrade' | 'Message' | 'PeerSubscribed' | 'PeerUnsubscribed' | 'GossipsubOutboundFailure' | 'GossipsubProtocolViolation' | 'PeerDiscovered' | 'PeerUpdated' | 'PeerExpired' | 'DiscoveryDialFailed' | 'DiscoveryProtocolViolation']
+    typeof P2pEvent['EventsDropped' | 'DriverFailed' | 'EndpointClosed' | 'ConnectionEstablished' | 'ConnectionClosed' | 'ConnectionReplaced' | 'PeerReady' | 'IdentifyReceived' | 'PingRttMeasured' | 'PingTimeout' | 'StreamReady' | 'StreamData' | 'StreamWriteAccepted' | 'StreamWriteStopped' | 'StreamRemoteWriteClosed' | 'StreamClosed' | 'EndpointError' | 'ReachabilityChanged' | 'PublicAddressesChanged' | 'RelayReserved' | 'RelayReservationLost' | 'PathEstablished' | 'InboundPathEstablished' | 'PathUpgraded' | 'HolePunchFailed' | 'ConnectFailed' | 'ConnectCancelled' | 'InboundDirectUpgrade' | 'Message' | 'PeerSubscribed' | 'PeerUnsubscribed' | 'GossipsubOutboundFailure' | 'GossipsubProtocolViolation' | 'PeerDiscovered' | 'PeerUpdated' | 'PeerExpired' | 'DiscoveryDialFailed' | 'MdnsFailed' | 'MdnsRecovered' | 'DiscoveryProtocolViolation']
 >;
 
 // FfiConverter for enum P2pEvent
@@ -3349,41 +3961,44 @@ const FfiConverterTypeP2pEvent = (() => {
             switch (c.readI32()) {
                 case 1: return new P2pEvent.EventsDropped({dropped: FfiConverterUInt64.readFromCursor(c), totalDropped: FfiConverterUInt64.readFromCursor(c), terminalConnectIds: FfiConverterSequenceUInt64.readFromCursor(c) });
                 case 2: return new P2pEvent.DriverFailed({kind: FfiConverterTypeDriverFailureKind.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
-                case 3: return new P2pEvent.ConnectionEstablished({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c) });
-                case 4: return new P2pEvent.ConnectionClosed({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c) });
-                case 5: return new P2pEvent.ConnectionReplaced({peerId: FfiConverterString.readFromCursor(c), oldConnId: FfiConverterUInt64.readFromCursor(c), newConnId: FfiConverterUInt64.readFromCursor(c) });
-                case 6: return new P2pEvent.PeerReady({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), protocols: FfiConverterSequenceString.readFromCursor(c) });
-                case 7: return new P2pEvent.IdentifyReceived({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), info: FfiConverterTypeIdentifyInfo.readFromCursor(c) });
-                case 8: return new P2pEvent.PingRttMeasured({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), rttMs: FfiConverterUInt64.readFromCursor(c) });
-                case 9: return new P2pEvent.PingTimeout({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c) });
-                case 10: return new P2pEvent.StreamReady({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c), protocolId: FfiConverterString.readFromCursor(c), initiatedLocally: FfiConverterBool.readFromCursor(c) });
-                case 11: return new P2pEvent.StreamData({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c), data: FfiConverterArrayBuffer.readFromCursor(c) });
-                case 12: return new P2pEvent.StreamWriteAccepted({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c) });
-                case 13: return new P2pEvent.StreamWriteStopped({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c), errorCode: FfiConverterUInt64.readFromCursor(c) });
-                case 14: return new P2pEvent.StreamRemoteWriteClosed({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c) });
-                case 15: return new P2pEvent.StreamClosed({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c) });
-                case 16: return new P2pEvent.EndpointError({kind: FfiConverterTypeEndpointErrorKind.readFromCursor(c), peerId: FfiConverterOptionalString.readFromCursor(c), connId: FfiConverterOptionalUInt64.readFromCursor(c), streamId: FfiConverterOptionalUInt64.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
-                case 17: return new P2pEvent.ReachabilityChanged({previous: FfiConverterTypeReachability.readFromCursor(c), current: FfiConverterTypeReachability.readFromCursor(c), confirmedAddrs: FfiConverterSequenceString.readFromCursor(c) });
-                case 18: return new P2pEvent.PublicAddressesChanged({addrs: FfiConverterSequenceString.readFromCursor(c) });
-                case 19: return new P2pEvent.RelayReserved({relayPeerId: FfiConverterString.readFromCursor(c), expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c) });
-                case 20: return new P2pEvent.RelayReservationLost({relayPeerId: FfiConverterString.readFromCursor(c) });
-                case 21: return new P2pEvent.PathEstablished({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), path: FfiConverterTypePathKind.readFromCursor(c) });
-                case 22: return new P2pEvent.InboundPathEstablished({peerId: FfiConverterString.readFromCursor(c), path: FfiConverterTypePathKind.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c) });
-                case 23: return new P2pEvent.PathUpgraded({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), from: FfiConverterTypePathKind.readFromCursor(c), to: FfiConverterTypePathKind.readFromCursor(c), oldConnId: FfiConverterUInt64.readFromCursor(c), newConnId: FfiConverterUInt64.readFromCursor(c) });
-                case 24: return new P2pEvent.HolePunchFailed({connectId: FfiConverterUInt64.readFromCursor(c), attempt: FfiConverterUInt32.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
-                case 25: return new P2pEvent.ConnectFailed({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), kind: FfiConverterTypeNatErrorKind.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
-                case 26: return new P2pEvent.ConnectCancelled({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c) });
-                case 27: return new P2pEvent.InboundDirectUpgrade({peerId: FfiConverterString.readFromCursor(c), oldConnId: FfiConverterUInt64.readFromCursor(c), newConnId: FfiConverterUInt64.readFromCursor(c) });
-                case 28: return new P2pEvent.Message({fromPeerId: FfiConverterString.readFromCursor(c), topics: FfiConverterSequenceString.readFromCursor(c), data: FfiConverterArrayBuffer.readFromCursor(c), seqno: FfiConverterArrayBuffer.readFromCursor(c), signed: FfiConverterBool.readFromCursor(c) });
-                case 29: return new P2pEvent.PeerSubscribed({peerId: FfiConverterString.readFromCursor(c), topic: FfiConverterString.readFromCursor(c) });
-                case 30: return new P2pEvent.PeerUnsubscribed({peerId: FfiConverterString.readFromCursor(c), topic: FfiConverterString.readFromCursor(c) });
-                case 31: return new P2pEvent.GossipsubOutboundFailure({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
-                case 32: return new P2pEvent.GossipsubProtocolViolation({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
-                case 33: return new P2pEvent.PeerDiscovered({peerId: FfiConverterString.readFromCursor(c), addrs: FfiConverterSequenceString.readFromCursor(c), source: FfiConverterTypeDiscoverySource.readFromCursor(c) });
-                case 34: return new P2pEvent.PeerUpdated({peerId: FfiConverterString.readFromCursor(c), addrs: FfiConverterSequenceString.readFromCursor(c), source: FfiConverterTypeDiscoverySource.readFromCursor(c) });
-                case 35: return new P2pEvent.PeerExpired({peerId: FfiConverterString.readFromCursor(c) });
-                case 36: return new P2pEvent.DiscoveryDialFailed({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
-                case 37: return new P2pEvent.DiscoveryProtocolViolation({peerId: FfiConverterOptionalString.readFromCursor(c), source: FfiConverterTypeDiscoverySource.readFromCursor(c), reason: FfiConverterString.readFromCursor(c), suppressed: FfiConverterUInt32.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 5: return new P2pEvent.ConnectionClosed({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), reason: FfiConverterTypeConnectionCloseReason.readFromCursor(c) });
+                case 6: return new P2pEvent.ConnectionReplaced({peerId: FfiConverterString.readFromCursor(c), oldConnId: FfiConverterUInt64.readFromCursor(c), newConnId: FfiConverterUInt64.readFromCursor(c) });
+                case 7: return new P2pEvent.PeerReady({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), protocols: FfiConverterSequenceString.readFromCursor(c) });
+                case 8: return new P2pEvent.IdentifyReceived({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), info: FfiConverterTypeIdentifyInfo.readFromCursor(c) });
+                case 9: return new P2pEvent.PingRttMeasured({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), rttMs: FfiConverterUInt64.readFromCursor(c) });
+                case 10: return new P2pEvent.PingTimeout({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c) });
+                case 11: return new P2pEvent.StreamReady({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c), protocolId: FfiConverterString.readFromCursor(c), initiatedLocally: FfiConverterBool.readFromCursor(c) });
+                case 12: return new P2pEvent.StreamData({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c), data: FfiConverterArrayBuffer.readFromCursor(c) });
+                case 13: return new P2pEvent.StreamWriteAccepted({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c) });
+                case 14: return new P2pEvent.StreamWriteStopped({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c), errorCode: FfiConverterUInt64.readFromCursor(c) });
+                case 15: return new P2pEvent.StreamRemoteWriteClosed({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c) });
+                case 16: return new P2pEvent.StreamClosed({peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), streamId: FfiConverterUInt64.readFromCursor(c) });
+                case 17: return new P2pEvent.EndpointError({kind: FfiConverterTypeEndpointErrorKind.readFromCursor(c), peerId: FfiConverterOptionalString.readFromCursor(c), connId: FfiConverterOptionalUInt64.readFromCursor(c), streamId: FfiConverterOptionalUInt64.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
+                case 18: return new P2pEvent.ReachabilityChanged({previous: FfiConverterTypeReachability.readFromCursor(c), current: FfiConverterTypeReachability.readFromCursor(c), confirmedAddrs: FfiConverterSequenceString.readFromCursor(c) });
+                case 19: return new P2pEvent.PublicAddressesChanged({addrs: FfiConverterSequenceString.readFromCursor(c) });
+                case 20: return new P2pEvent.RelayReserved({relayPeerId: FfiConverterString.readFromCursor(c), expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c) });
+                case 21: return new P2pEvent.RelayReservationLost({relayPeerId: FfiConverterString.readFromCursor(c) });
+                case 22: return new P2pEvent.PathEstablished({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), path: FfiConverterTypePathKind.readFromCursor(c) });
+                case 23: return new P2pEvent.InboundPathEstablished({peerId: FfiConverterString.readFromCursor(c), path: FfiConverterTypePathKind.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c) });
+                case 24: return new P2pEvent.PathUpgraded({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), from: FfiConverterTypePathKind.readFromCursor(c), to: FfiConverterTypePathKind.readFromCursor(c), oldConnId: FfiConverterUInt64.readFromCursor(c), newConnId: FfiConverterUInt64.readFromCursor(c) });
+                case 25: return new P2pEvent.HolePunchFailed({connectId: FfiConverterUInt64.readFromCursor(c), attempt: FfiConverterUInt32.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 26: return new P2pEvent.ConnectFailed({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), kind: FfiConverterTypeNatErrorKind.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
+                case 27: return new P2pEvent.ConnectCancelled({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c) });
+                case 28: return new P2pEvent.InboundDirectUpgrade({peerId: FfiConverterString.readFromCursor(c), oldConnId: FfiConverterUInt64.readFromCursor(c), newConnId: FfiConverterUInt64.readFromCursor(c) });
+                case 29: return new P2pEvent.Message({fromPeerId: FfiConverterString.readFromCursor(c), topics: FfiConverterSequenceString.readFromCursor(c), data: FfiConverterArrayBuffer.readFromCursor(c), seqno: FfiConverterArrayBuffer.readFromCursor(c), signed: FfiConverterBool.readFromCursor(c) });
+                case 30: return new P2pEvent.PeerSubscribed({peerId: FfiConverterString.readFromCursor(c), topic: FfiConverterString.readFromCursor(c) });
+                case 31: return new P2pEvent.PeerUnsubscribed({peerId: FfiConverterString.readFromCursor(c), topic: FfiConverterString.readFromCursor(c) });
+                case 32: return new P2pEvent.GossipsubOutboundFailure({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 33: return new P2pEvent.GossipsubProtocolViolation({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 34: return new P2pEvent.PeerDiscovered({peerId: FfiConverterString.readFromCursor(c), addrs: FfiConverterSequenceString.readFromCursor(c), source: FfiConverterTypeDiscoverySource.readFromCursor(c) });
+                case 35: return new P2pEvent.PeerUpdated({peerId: FfiConverterString.readFromCursor(c), addrs: FfiConverterSequenceString.readFromCursor(c), source: FfiConverterTypeDiscoverySource.readFromCursor(c) });
+                case 36: return new P2pEvent.PeerExpired({peerId: FfiConverterString.readFromCursor(c) });
+                case 37: return new P2pEvent.DiscoveryDialFailed({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                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), reason: FfiConverterString.readFromCursor(c), suppressed: FfiConverterUInt32.readFromCursor(c) });
                 default: throw new UniffiInternalError.UnexpectedEnumCase();
             }
         }
@@ -3404,22 +4019,30 @@ 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);
@@ -3427,7 +4050,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.PeerReady: {
-                    c.writeI32(6);
+                    c.writeI32(7);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -3435,7 +4058,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.IdentifyReceived: {
-                    c.writeI32(7);
+                    c.writeI32(8);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -3443,7 +4066,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.PingRttMeasured: {
-                    c.writeI32(8);
+                    c.writeI32(9);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -3451,14 +4074,14 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.PingTimeout: {
-                    c.writeI32(9);
+                    c.writeI32(10);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.connId, c);
                     return;
                 }
                 case P2pEvent_Tags.StreamReady: {
-                    c.writeI32(10);
+                    c.writeI32(11);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -3468,7 +4091,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.StreamData: {
-                    c.writeI32(11);
+                    c.writeI32(12);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -3477,7 +4100,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.StreamWriteAccepted: {
-                    c.writeI32(12);
+                    c.writeI32(13);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -3485,7 +4108,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.StreamWriteStopped: {
-                    c.writeI32(13);
+                    c.writeI32(14);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -3494,7 +4117,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.StreamRemoteWriteClosed: {
-                    c.writeI32(14);
+                    c.writeI32(15);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -3502,7 +4125,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.StreamClosed: {
-                    c.writeI32(15);
+                    c.writeI32(16);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.connId, c);
@@ -3510,7 +4133,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.EndpointError: {
-                    c.writeI32(16);
+                    c.writeI32(17);
                     const inner = value.inner;
                     FfiConverterTypeEndpointErrorKind.writeIntoCursor(inner.kind, c);
                     FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
@@ -3520,7 +4143,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.ReachabilityChanged: {
-                    c.writeI32(17);
+                    c.writeI32(18);
                     const inner = value.inner;
                     FfiConverterTypeReachability.writeIntoCursor(inner.previous, c);
                     FfiConverterTypeReachability.writeIntoCursor(inner.current, c);
@@ -3528,26 +4151,26 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 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);
                     return;
                 }
                 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);
@@ -3556,7 +4179,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.InboundPathEstablished: {
-                    c.writeI32(22);
+                    c.writeI32(23);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
@@ -3564,7 +4187,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.PathUpgraded: {
-                    c.writeI32(23);
+                    c.writeI32(24);
                     const inner = value.inner;
                     FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -3575,7 +4198,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.HolePunchFailed: {
-                    c.writeI32(24);
+                    c.writeI32(25);
                     const inner = value.inner;
                     FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
                     FfiConverterUInt32.writeIntoCursor(inner.attempt, c);
@@ -3583,7 +4206,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.ConnectFailed: {
-                    c.writeI32(25);
+                    c.writeI32(26);
                     const inner = value.inner;
                     FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -3592,14 +4215,14 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.ConnectCancelled: {
-                    c.writeI32(26);
+                    c.writeI32(27);
                     const inner = value.inner;
                     FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     return;
                 }
                 case P2pEvent_Tags.InboundDirectUpgrade: {
-                    c.writeI32(27);
+                    c.writeI32(28);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.oldConnId, c);
@@ -3607,7 +4230,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.Message: {
-                    c.writeI32(28);
+                    c.writeI32(29);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.fromPeerId, c);
                     FfiConverterSequenceString.writeIntoCursor(inner.topics, c);
@@ -3617,35 +4240,35 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.PeerSubscribed: {
-                    c.writeI32(29);
+                    c.writeI32(30);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterString.writeIntoCursor(inner.topic, c);
                     return;
                 }
                 case P2pEvent_Tags.PeerUnsubscribed: {
-                    c.writeI32(30);
+                    c.writeI32(31);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterString.writeIntoCursor(inner.topic, c);
                     return;
                 }
                 case P2pEvent_Tags.GossipsubOutboundFailure: {
-                    c.writeI32(31);
+                    c.writeI32(32);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterString.writeIntoCursor(inner.reason, c);
                     return;
                 }
                 case P2pEvent_Tags.GossipsubProtocolViolation: {
-                    c.writeI32(32);
+                    c.writeI32(33);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterString.writeIntoCursor(inner.reason, c);
                     return;
                 }
                 case P2pEvent_Tags.PeerDiscovered: {
-                    c.writeI32(33);
+                    c.writeI32(34);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
@@ -3653,7 +4276,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.PeerUpdated: {
-                    c.writeI32(34);
+                    c.writeI32(35);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
@@ -3661,20 +4284,31 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 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);
@@ -3704,6 +4338,13 @@ 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;
                     let size = 4;
@@ -3716,6 +4357,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: {
@@ -3973,6 +4615,16 @@ 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;
                     let size = 4;
@@ -3989,15 +4641,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);
 
@@ -4013,6 +4665,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.
@@ -4038,7 +4693,10 @@ function uniffiEnsureInitialized() {
 export default Object.freeze({
   initialize: uniffiEnsureInitialized,
   converters: {
+    FfiConverterTypeCloseOutcome,
+    FfiConverterTypeConfigCapability,
     FfiConverterTypeConnectTarget,
+    FfiConverterTypeConnectionCloseReason,
     FfiConverterTypeConnectionInfo,
     FfiConverterTypeDiscoveryOptions,
     FfiConverterTypeDiscoverySource,
@@ -4048,6 +4706,7 @@ export default Object.freeze({
     FfiConverterTypeFfiError,
     FfiConverterTypeIdentifyInfo,
     FfiConverterTypeKnownPeerInfo,
+    FfiConverterTypeMdnsFailureKind,
     FfiConverterTypeMdnsOptions,
     FfiConverterTypeNatErrorKind,
     FfiConverterTypeOpenStreamResult,
@@ -4055,5 +4714,6 @@ export default Object.freeze({
     FfiConverterTypePathKind,
     FfiConverterTypeReachability,
     FfiConverterTypeRelayReservationInfo,
+    FfiConverterTypeUnfinishedConnection,
   }
 });