@minip2p/react-native 0.10.0 → 0.10.2

package/src/generated/minip2p_ffi_core.ts

@@ -475,6 +475,666 @@ const FfiConverterTypeMdnsOptions = (() => {
     return new FFIConverter();
 })();
 
+
+// Enum: WindowLimit
+export enum WindowLimit_Tags {
+    Bounded = "Bounded",
+    Unlimited = "Unlimited"
+}
+/**
+ * A receive window that may be unbounded.
+ */
+export const WindowLimit = (() => {
+
+    type Bounded__interface = {
+        tag: WindowLimit_Tags.Bounded;
+        inner:
+Readonly<{bytes: bigint}>
+    };
+    /**
+     * At most `bytes`.
+     */
+    class Bounded_ extends UniffiEnum implements Bounded__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "WindowLimit";
+        readonly tag = WindowLimit_Tags.Bounded;
+        readonly inner:
+Readonly<{bytes: bigint}>;
+        constructor(
+inner: {bytes: bigint }) {
+            super("WindowLimit", "Bounded");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {bytes: bigint }): Bounded_ {
+            return new Bounded_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Bounded_ {
+            return obj.tag === WindowLimit_Tags.Bounded;
+        }
+
+    }
+
+    type Unlimited__interface = {
+        tag: WindowLimit_Tags.Unlimited
+    };
+    /**
+     * No window.
+     */
+    class Unlimited_ extends UniffiEnum implements Unlimited__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "WindowLimit";
+        readonly tag = WindowLimit_Tags.Unlimited;
+        constructor() {
+            super("WindowLimit", "Unlimited");
+        }
+
+        static new(): Unlimited_ {
+            return new Unlimited_();
+        }
+
+        static instanceOf(obj: any): obj is Unlimited_ {
+            return obj.tag === WindowLimit_Tags.Unlimited;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is WindowLimit {
+        return obj[uniffiTypeNameSymbol] === "WindowLimit";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Bounded: Bounded_,
+  Unlimited: Unlimited_
+    });
+
+})();
+/**
+ * A receive window that may be unbounded.
+ */
+export type WindowLimit = InstanceType<
+    typeof WindowLimit['Bounded' | 'Unlimited']
+>;
+
+// FfiConverter for enum WindowLimit
+const FfiConverterTypeWindowLimit = (() => {
+    type TypeName = WindowLimit;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return new WindowLimit.Bounded({bytes: FfiConverterUInt64.readFromCursor(c) });
+                case 2: return new WindowLimit.Unlimited();
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value.tag) {
+                case WindowLimit_Tags.Bounded: {
+                    c.writeI32(1);
+                    const inner = value.inner;
+                    FfiConverterUInt64.writeIntoCursor(inner.bytes, c);
+                    return;
+                }
+                case WindowLimit_Tags.Unlimited: {
+                    c.writeI32(2);
+                    return;
+                }
+                default:
+                    // Throwing from here means that WindowLimit_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case WindowLimit_Tags.Bounded: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterUInt64.allocationSize(inner.bytes);
+                    return size;
+                }
+                case WindowLimit_Tags.Unlimited: {
+                    return 4;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * QUIC overrides; each field mirrors `minip2p::QuicLimits`.
+ */
+export type QuicLimitsOptions = {
+    /**
+     * Simultaneous connections, inbound and outbound.
+     */
+    maxConnections?: bigint,
+    /**
+     * Locally initiated bidirectional streams per connection.
+     */
+    maxStreamsPerConnection?: bigint,
+    /**
+     * Bytes queued per stream beyond what the engine accepts; non-zero.
+     */
+    maxPendingBytesPerStream?: bigint,
+    /**
+     * Bytes queued per connection beyond what the engine accepts; greater
+     * than `control_stream_reserve_bytes`.
+     */
+    maxPendingConnectionBytes?: bigint,
+    /**
+     * Part of the connection queue only control streams may fill.
+     */
+    controlStreamReserveBytes?: bigint,
+    /**
+     * UDP datagrams retained while the socket would block; non-zero.
+     */
+    maxPendingDatagrams?: bigint,
+    /**
+     * Idle timeout advertised to peers, in milliseconds; non-zero.
+     */
+    idleTimeoutMs?: bigint,
+    /**
+     * Whether inbound connections need a stateless Retry first.
+     */
+    requireAddressValidation?: boolean,
+    /**
+     * Per-stream receive window in bytes; non-zero.
+     */
+    streamReceiveWindow?: bigint,
+    /**
+     * Per-connection receive window (unlimited by default).
+     */
+    connectionReceiveWindow?: WindowLimit,
+    /**
+     * Bytes buffered per connection for sending; non-zero.
+     */
+    sendWindow?: bigint,
+    /**
+     * Time an `h3` connection has to complete Noise, in milliseconds;
+     * non-zero.
+     */
+    webtransportHandshakeTimeoutMs?: bigint
+}
+
+/**
+ * Generated factory for {@link QuicLimitsOptions} record objects.
+ */
+export const QuicLimitsOptions = (() => {
+    const defaults = () => ({
+        maxConnections: undefined,
+        maxStreamsPerConnection: undefined,
+        maxPendingBytesPerStream: undefined,
+        maxPendingConnectionBytes: undefined,
+        controlStreamReserveBytes: undefined,
+        maxPendingDatagrams: undefined,
+        idleTimeoutMs: undefined,
+        requireAddressValidation: undefined,
+        streamReceiveWindow: undefined,
+        connectionReceiveWindow: undefined,
+        sendWindow: undefined,
+        webtransportHandshakeTimeoutMs: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<QuicLimitsOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<QuicLimitsOptions>,
+    });
+})();
+
+const FfiConverterTypeQuicLimitsOptions = (() => {
+    type TypeName = QuicLimitsOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                maxConnections: FfiConverterOptionalUInt64.readFromCursor(c),
+                maxStreamsPerConnection: FfiConverterOptionalUInt64.readFromCursor(c),
+                maxPendingBytesPerStream: FfiConverterOptionalUInt64.readFromCursor(c),
+                maxPendingConnectionBytes: FfiConverterOptionalUInt64.readFromCursor(c),
+                controlStreamReserveBytes: FfiConverterOptionalUInt64.readFromCursor(c),
+                maxPendingDatagrams: FfiConverterOptionalUInt64.readFromCursor(c),
+                idleTimeoutMs: FfiConverterOptionalUInt64.readFromCursor(c),
+                requireAddressValidation: FfiConverterOptionalBoolean.readFromCursor(c),
+                streamReceiveWindow: FfiConverterOptionalUInt64.readFromCursor(c),
+                connectionReceiveWindow: FfiConverterOptionalTypeWindowLimit.readFromCursor(c),
+                sendWindow: FfiConverterOptionalUInt64.readFromCursor(c),
+                webtransportHandshakeTimeoutMs: FfiConverterOptionalUInt64.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxConnections, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxStreamsPerConnection, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxPendingBytesPerStream, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxPendingConnectionBytes, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.controlStreamReserveBytes, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxPendingDatagrams, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.idleTimeoutMs, c);
+            FfiConverterOptionalBoolean.writeIntoCursor(value.requireAddressValidation, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.streamReceiveWindow, c);
+            FfiConverterOptionalTypeWindowLimit.writeIntoCursor(value.connectionReceiveWindow, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.sendWindow, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.webtransportHandshakeTimeoutMs, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalUInt64.allocationSize(value.maxConnections) +
+             FfiConverterOptionalUInt64.allocationSize(value.maxStreamsPerConnection) +
+             FfiConverterOptionalUInt64.allocationSize(value.maxPendingBytesPerStream) +
+             FfiConverterOptionalUInt64.allocationSize(value.maxPendingConnectionBytes) +
+             FfiConverterOptionalUInt64.allocationSize(value.controlStreamReserveBytes) +
+             FfiConverterOptionalUInt64.allocationSize(value.maxPendingDatagrams) +
+             FfiConverterOptionalUInt64.allocationSize(value.idleTimeoutMs) +
+             FfiConverterOptionalBoolean.allocationSize(value.requireAddressValidation) +
+             FfiConverterOptionalUInt64.allocationSize(value.streamReceiveWindow) +
+             FfiConverterOptionalTypeWindowLimit.allocationSize(value.connectionReceiveWindow) +
+             FfiConverterOptionalUInt64.allocationSize(value.sendWindow) +
+             FfiConverterOptionalUInt64.allocationSize(value.webtransportHandshakeTimeoutMs);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+
+// Enum: TimeoutLimit
+export enum TimeoutLimit_Tags {
+    AfterMs = "AfterMs",
+    Never = "Never"
+}
+/**
+ * A timeout that may be disabled.
+ */
+export const TimeoutLimit = (() => {
+
+    type AfterMs__interface = {
+        tag: TimeoutLimit_Tags.AfterMs;
+        inner:
+Readonly<{ms: bigint}>
+    };
+    /**
+     * Fires after `ms` milliseconds.
+     */
+    class AfterMs_ extends UniffiEnum implements AfterMs__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "TimeoutLimit";
+        readonly tag = TimeoutLimit_Tags.AfterMs;
+        readonly inner:
+Readonly<{ms: bigint}>;
+        constructor(
+inner: {ms: bigint }) {
+            super("TimeoutLimit", "AfterMs");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {ms: bigint }): AfterMs_ {
+            return new AfterMs_(inner);
+        }
+
+        static instanceOf(obj: any): obj is AfterMs_ {
+            return obj.tag === TimeoutLimit_Tags.AfterMs;
+        }
+
+    }
+
+    type Never__interface = {
+        tag: TimeoutLimit_Tags.Never
+    };
+    /**
+     * Waits indefinitely.
+     */
+    class Never_ extends UniffiEnum implements Never__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "TimeoutLimit";
+        readonly tag = TimeoutLimit_Tags.Never;
+        constructor() {
+            super("TimeoutLimit", "Never");
+        }
+
+        static new(): Never_ {
+            return new Never_();
+        }
+
+        static instanceOf(obj: any): obj is Never_ {
+            return obj.tag === TimeoutLimit_Tags.Never;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is TimeoutLimit {
+        return obj[uniffiTypeNameSymbol] === "TimeoutLimit";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  AfterMs: AfterMs_,
+  Never: Never_
+    });
+
+})();
+/**
+ * A timeout that may be disabled.
+ */
+export type TimeoutLimit = InstanceType<
+    typeof TimeoutLimit['AfterMs' | 'Never']
+>;
+
+// FfiConverter for enum TimeoutLimit
+const FfiConverterTypeTimeoutLimit = (() => {
+    type TypeName = TimeoutLimit;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return new TimeoutLimit.AfterMs({ms: FfiConverterUInt64.readFromCursor(c) });
+                case 2: return new TimeoutLimit.Never();
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value.tag) {
+                case TimeoutLimit_Tags.AfterMs: {
+                    c.writeI32(1);
+                    const inner = value.inner;
+                    FfiConverterUInt64.writeIntoCursor(inner.ms, c);
+                    return;
+                }
+                case TimeoutLimit_Tags.Never: {
+                    c.writeI32(2);
+                    return;
+                }
+                default:
+                    // Throwing from here means that TimeoutLimit_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case TimeoutLimit_Tags.AfterMs: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterUInt64.allocationSize(inner.ms);
+                    return size;
+                }
+                case TimeoutLimit_Tags.Never: {
+                    return 4;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Yamux overrides; each field mirrors `minip2p::YamuxConfig`.
+ */
+export type YamuxOptions = {
+    /**
+     * Per-stream receive window in bytes; at least 256 KiB.
+     */
+    receiveWindow?: number,
+    /**
+     * Largest data-frame payload sent; non-zero.
+     */
+    maxFrameLen?: number,
+    /**
+     * Streams tracked at once, counting unsettled closed ones.
+     */
+    maxStreams?: bigint,
+    /**
+     * Per-stream cap on accepted, unpulled send bytes; non-zero.
+     */
+    maxBufferedSend?: bigint,
+    /**
+     * Session-wide cap on accepted, unpulled send bytes; greater than
+     * `control_stream_reserve`.
+     */
+    maxTotalBufferedSend?: bigint,
+    /**
+     * Part of the session-wide cap only control streams may fill.
+     */
+    controlStreamReserve?: bigint,
+    /**
+     * Control frames that may wait to be pulled.
+     */
+    maxPendingControl?: bigint
+}
+
+/**
+ * Generated factory for {@link YamuxOptions} record objects.
+ */
+export const YamuxOptions = (() => {
+    const defaults = () => ({
+        receiveWindow: undefined,
+        maxFrameLen: undefined,
+        maxStreams: undefined,
+        maxBufferedSend: undefined,
+        maxTotalBufferedSend: undefined,
+        controlStreamReserve: undefined,
+        maxPendingControl: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<YamuxOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<YamuxOptions>,
+    });
+})();
+
+const FfiConverterTypeYamuxOptions = (() => {
+    type TypeName = YamuxOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                receiveWindow: FfiConverterOptionalUInt32.readFromCursor(c),
+                maxFrameLen: FfiConverterOptionalUInt32.readFromCursor(c),
+                maxStreams: FfiConverterOptionalUInt64.readFromCursor(c),
+                maxBufferedSend: FfiConverterOptionalUInt64.readFromCursor(c),
+                maxTotalBufferedSend: FfiConverterOptionalUInt64.readFromCursor(c),
+                controlStreamReserve: FfiConverterOptionalUInt64.readFromCursor(c),
+                maxPendingControl: FfiConverterOptionalUInt64.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterOptionalUInt32.writeIntoCursor(value.receiveWindow, c);
+            FfiConverterOptionalUInt32.writeIntoCursor(value.maxFrameLen, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxStreams, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxBufferedSend, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxTotalBufferedSend, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.controlStreamReserve, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxPendingControl, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalUInt32.allocationSize(value.receiveWindow) +
+             FfiConverterOptionalUInt32.allocationSize(value.maxFrameLen) +
+             FfiConverterOptionalUInt64.allocationSize(value.maxStreams) +
+             FfiConverterOptionalUInt64.allocationSize(value.maxBufferedSend) +
+             FfiConverterOptionalUInt64.allocationSize(value.maxTotalBufferedSend) +
+             FfiConverterOptionalUInt64.allocationSize(value.controlStreamReserve) +
+             FfiConverterOptionalUInt64.allocationSize(value.maxPendingControl);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * TCP overrides; each field mirrors `minip2p::TcpConfig` (its connection-id
+ * namespace stays internal).
+ */
+export type TcpLimitsOptions = {
+    /**
+     * Connections held at once, dialed and accepted alike.
+     */
+    maxConnections?: bigint,
+    /**
+     * How long a connection may take to authenticate.
+     */
+    handshakeTimeoutMs?: TimeoutLimit,
+    /**
+     * Encrypted bytes one connection holds for its socket.
+     */
+    maxBufferedSend?: bigint,
+    /**
+     * How long a connection may hold bytes its socket refuses.
+     */
+    sendStallTimeoutMs?: TimeoutLimit,
+    /**
+     * Each TCP connection's Yamux limits; independent of
+     * [`LimitsOptions::circuit`].
+     */
+    yamux?: YamuxOptions
+}
+
+/**
+ * Generated factory for {@link TcpLimitsOptions} record objects.
+ */
+export const TcpLimitsOptions = (() => {
+    const defaults = () => ({
+        maxConnections: undefined,
+        handshakeTimeoutMs: undefined,
+        maxBufferedSend: undefined,
+        sendStallTimeoutMs: undefined,
+        yamux: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<TcpLimitsOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<TcpLimitsOptions>,
+    });
+})();
+
+const FfiConverterTypeTcpLimitsOptions = (() => {
+    type TypeName = TcpLimitsOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                maxConnections: FfiConverterOptionalUInt64.readFromCursor(c),
+                handshakeTimeoutMs: FfiConverterOptionalTypeTimeoutLimit.readFromCursor(c),
+                maxBufferedSend: FfiConverterOptionalUInt64.readFromCursor(c),
+                sendStallTimeoutMs: FfiConverterOptionalTypeTimeoutLimit.readFromCursor(c),
+                yamux: FfiConverterOptionalTypeYamuxOptions.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxConnections, c);
+            FfiConverterOptionalTypeTimeoutLimit.writeIntoCursor(value.handshakeTimeoutMs, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxBufferedSend, c);
+            FfiConverterOptionalTypeTimeoutLimit.writeIntoCursor(value.sendStallTimeoutMs, c);
+            FfiConverterOptionalTypeYamuxOptions.writeIntoCursor(value.yamux, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalUInt64.allocationSize(value.maxConnections) +
+             FfiConverterOptionalTypeTimeoutLimit.allocationSize(value.handshakeTimeoutMs) +
+             FfiConverterOptionalUInt64.allocationSize(value.maxBufferedSend) +
+             FfiConverterOptionalTypeTimeoutLimit.allocationSize(value.sendStallTimeoutMs) +
+             FfiConverterOptionalTypeYamuxOptions.allocationSize(value.yamux);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Transport limit overrides.
+ *
+ * Every field is optional: an absent record or field keeps the native
+ * default, so an omitted record and an empty one behave identically. Limits
+ * for a transport the endpoint does not bind (TCP without a `/tcp` listen
+ * address, say) are ignored, not validated. An invalid limit fails
+ * construction with `InvalidConfig { capability: Transport }`.
+ */
+export type LimitsOptions = {
+    /**
+     * QUIC (and WebTransport) transport limits.
+     */
+    quic?: QuicLimitsOptions,
+    /**
+     * TCP transport limits, including its connections' Yamux limits.
+     */
+    tcp?: TcpLimitsOptions,
+    /**
+     * Relay circuits' Yamux limits; independent of [`TcpLimitsOptions::yamux`].
+     */
+    circuit?: YamuxOptions,
+    /**
+     * Most relayed circuits held at once (`NatConfig::max_circuits`): past
+     * it inbound circuits are refused and relay legs fail.
+     */
+    maxCircuits?: bigint
+}
+
+/**
+ * Generated factory for {@link LimitsOptions} record objects.
+ */
+export const LimitsOptions = (() => {
+    const defaults = () => ({
+        quic: undefined,
+        tcp: undefined,
+        circuit: undefined,
+        maxCircuits: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<LimitsOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<LimitsOptions>,
+    });
+})();
+
+const FfiConverterTypeLimitsOptions = (() => {
+    type TypeName = LimitsOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                quic: FfiConverterOptionalTypeQuicLimitsOptions.readFromCursor(c),
+                tcp: FfiConverterOptionalTypeTcpLimitsOptions.readFromCursor(c),
+                circuit: FfiConverterOptionalTypeYamuxOptions.readFromCursor(c),
+                maxCircuits: FfiConverterOptionalUInt64.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterOptionalTypeQuicLimitsOptions.writeIntoCursor(value.quic, c);
+            FfiConverterOptionalTypeTcpLimitsOptions.writeIntoCursor(value.tcp, c);
+            FfiConverterOptionalTypeYamuxOptions.writeIntoCursor(value.circuit, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.maxCircuits, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalTypeQuicLimitsOptions.allocationSize(value.quic) +
+             FfiConverterOptionalTypeTcpLimitsOptions.allocationSize(value.tcp) +
+             FfiConverterOptionalTypeYamuxOptions.allocationSize(value.circuit) +
+             FfiConverterOptionalUInt64.allocationSize(value.maxCircuits);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
 /**
  * Configuration used to construct an FFI endpoint.
  */
@@ -518,7 +1178,11 @@ export type EndpointConfig = {
     /**
      * Local-link mDNS settings, or no mDNS discovery when absent.
      */
-    mdns?: MdnsOptions
+    mdns?: MdnsOptions,
+    /**
+     * Transport limit overrides, or every native default when absent.
+     */
+    limits?: LimitsOptions
 }
 
 /**
@@ -550,7 +1214,8 @@ const FfiConverterTypeEndpointConfig = (() => {
                 allowUnsigned: FfiConverterBool.readFromCursor(c),
                 protocols: FfiConverterSequenceString.readFromCursor(c),
                 discovery: FfiConverterOptionalTypeDiscoveryOptions.readFromCursor(c),
-                mdns: FfiConverterOptionalTypeMdnsOptions.readFromCursor(c)
+                mdns: FfiConverterOptionalTypeMdnsOptions.readFromCursor(c),
+                limits: FfiConverterOptionalTypeLimitsOptions.readFromCursor(c)
             };
         }
         writeIntoCursor(value: TypeName, c: Cursor): void {
@@ -563,6 +1228,7 @@ const FfiConverterTypeEndpointConfig = (() => {
             FfiConverterSequenceString.writeIntoCursor(value.protocols, c);
             FfiConverterOptionalTypeDiscoveryOptions.writeIntoCursor(value.discovery, c);
             FfiConverterOptionalTypeMdnsOptions.writeIntoCursor(value.mdns, c);
+            FfiConverterOptionalTypeLimitsOptions.writeIntoCursor(value.limits, c);
         }
         allocationSize(value: TypeName): number {
             return FfiConverterOptionalString.allocationSize(value.agentVersion) +
@@ -573,7 +1239,8 @@ const FfiConverterTypeEndpointConfig = (() => {
              FfiConverterBool.allocationSize(value.allowUnsigned) +
              FfiConverterSequenceString.allocationSize(value.protocols) +
              FfiConverterOptionalTypeDiscoveryOptions.allocationSize(value.discovery) +
-             FfiConverterOptionalTypeMdnsOptions.allocationSize(value.mdns);
+             FfiConverterOptionalTypeMdnsOptions.allocationSize(value.mdns) +
+             FfiConverterOptionalTypeLimitsOptions.allocationSize(value.limits);
 
         }
     };
@@ -2498,6 +3165,7 @@ export enum P2pEvent_Tags {
     StreamClosed = "StreamClosed",
     EndpointError = "EndpointError",
     ReachabilityChanged = "ReachabilityChanged",
+    ListenAddressesChanged = "ListenAddressesChanged",
     PublicAddressesChanged = "PublicAddressesChanged",
     RelayReserved = "RelayReserved",
     RelayReservationLost = "RelayReservationLost",
@@ -3147,6 +3815,43 @@ inner: {previous: Reachability; current: Reachability; confirmedAddrs: Array<str
 
     }
 
+    type ListenAddressesChanged__interface = {
+        tag: P2pEvent_Tags.ListenAddressesChanged;
+        inner:
+Readonly<{addrs: Array<string>}>
+    };
+    /**
+     * 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 implements ListenAddressesChanged__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "P2pEvent";
+        readonly tag = P2pEvent_Tags.ListenAddressesChanged;
+        readonly inner:
+Readonly<{addrs: Array<string>}>;
+        constructor(
+inner: {addrs: Array<string> }) {
+            super("P2pEvent", "ListenAddressesChanged");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {addrs: Array<string> }): ListenAddressesChanged_ {
+            return new ListenAddressesChanged_(inner);
+        }
+
+        static instanceOf(obj: any): obj is ListenAddressesChanged_ {
+            return obj.tag === P2pEvent_Tags.ListenAddressesChanged;
+        }
+
+    }
+
     type PublicAddressesChanged__interface = {
         tag: P2pEvent_Tags.PublicAddressesChanged;
         inner:
@@ -3921,6 +4626,7 @@ inner: {peerId?: string; source: DiscoverySource; reason: string; suppressed: nu
   StreamClosed: StreamClosed_,
   EndpointError: EndpointError_,
   ReachabilityChanged: ReachabilityChanged_,
+  ListenAddressesChanged: ListenAddressesChanged_,
   PublicAddressesChanged: PublicAddressesChanged_,
   RelayReserved: RelayReserved_,
   RelayReservationLost: RelayReservationLost_,
@@ -3950,7 +4656,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' | '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']
+    typeof P2pEvent['EventsDropped' | 'DriverFailed' | 'EndpointClosed' | 'ConnectionEstablished' | 'ConnectionClosed' | 'ConnectionReplaced' | 'PeerReady' | 'IdentifyReceived' | 'PingRttMeasured' | 'PingTimeout' | 'StreamReady' | 'StreamData' | 'StreamWriteAccepted' | 'StreamWriteStopped' | 'StreamRemoteWriteClosed' | 'StreamClosed' | 'EndpointError' | 'ReachabilityChanged' | 'ListenAddressesChanged' | '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
@@ -3977,28 +4683,29 @@ const FfiConverterTypeP2pEvent = (() => {
                 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) });
+                case 19: return new P2pEvent.ListenAddressesChanged({addrs: FfiConverterSequenceString.readFromCursor(c) });
+                case 20: return new P2pEvent.PublicAddressesChanged({addrs: FfiConverterSequenceString.readFromCursor(c) });
+                case 21: return new P2pEvent.RelayReserved({relayPeerId: FfiConverterString.readFromCursor(c), expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c) });
+                case 22: return new P2pEvent.RelayReservationLost({relayPeerId: FfiConverterString.readFromCursor(c) });
+                case 23: return new P2pEvent.PathEstablished({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c), path: FfiConverterTypePathKind.readFromCursor(c) });
+                case 24: return new P2pEvent.InboundPathEstablished({peerId: FfiConverterString.readFromCursor(c), path: FfiConverterTypePathKind.readFromCursor(c), connId: FfiConverterUInt64.readFromCursor(c) });
+                case 25: 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 26: return new P2pEvent.HolePunchFailed({connectId: FfiConverterUInt64.readFromCursor(c), attempt: FfiConverterUInt32.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 27: return new P2pEvent.ConnectFailed({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c), kind: FfiConverterTypeNatErrorKind.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
+                case 28: return new P2pEvent.ConnectCancelled({connectId: FfiConverterUInt64.readFromCursor(c), peerId: FfiConverterString.readFromCursor(c) });
+                case 29: return new P2pEvent.InboundDirectUpgrade({peerId: FfiConverterString.readFromCursor(c), oldConnId: FfiConverterUInt64.readFromCursor(c), newConnId: FfiConverterUInt64.readFromCursor(c) });
+                case 30: 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 31: return new P2pEvent.PeerSubscribed({peerId: FfiConverterString.readFromCursor(c), topic: FfiConverterString.readFromCursor(c) });
+                case 32: return new P2pEvent.PeerUnsubscribed({peerId: FfiConverterString.readFromCursor(c), topic: FfiConverterString.readFromCursor(c) });
+                case 33: return new P2pEvent.GossipsubOutboundFailure({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 34: return new P2pEvent.GossipsubProtocolViolation({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 35: return new P2pEvent.PeerDiscovered({peerId: FfiConverterString.readFromCursor(c), addrs: FfiConverterSequenceString.readFromCursor(c), source: FfiConverterTypeDiscoverySource.readFromCursor(c) });
+                case 36: return new P2pEvent.PeerUpdated({peerId: FfiConverterString.readFromCursor(c), addrs: FfiConverterSequenceString.readFromCursor(c), source: FfiConverterTypeDiscoverySource.readFromCursor(c) });
+                case 37: return new P2pEvent.PeerExpired({peerId: FfiConverterString.readFromCursor(c) });
+                case 38: return new P2pEvent.DiscoveryDialFailed({peerId: FfiConverterString.readFromCursor(c), reason: FfiConverterString.readFromCursor(c) });
+                case 39: return new P2pEvent.MdnsFailed({kind: FfiConverterTypeMdnsFailureKind.readFromCursor(c), detail: FfiConverterString.readFromCursor(c) });
+                case 40: return new P2pEvent.MdnsRecovered();
+                case 41: 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();
             }
         }
@@ -4150,27 +4857,33 @@ const FfiConverterTypeP2pEvent = (() => {
                     FfiConverterSequenceString.writeIntoCursor(inner.confirmedAddrs, c);
                     return;
                 }
-                case P2pEvent_Tags.PublicAddressesChanged: {
+                case P2pEvent_Tags.ListenAddressesChanged: {
                     c.writeI32(19);
                     const inner = value.inner;
                     FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
                     return;
                 }
-                case P2pEvent_Tags.RelayReserved: {
+                case P2pEvent_Tags.PublicAddressesChanged: {
                     c.writeI32(20);
                     const inner = value.inner;
+                    FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
+                    return;
+                }
+                case P2pEvent_Tags.RelayReserved: {
+                    c.writeI32(21);
+                    const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
                     FfiConverterOptionalUInt64.writeIntoCursor(inner.expiresUnixSecs, c);
                     return;
                 }
                 case P2pEvent_Tags.RelayReservationLost: {
-                    c.writeI32(21);
+                    c.writeI32(22);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
                     return;
                 }
                 case P2pEvent_Tags.PathEstablished: {
-                    c.writeI32(22);
+                    c.writeI32(23);
                     const inner = value.inner;
                     FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -4179,7 +4892,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.InboundPathEstablished: {
-                    c.writeI32(23);
+                    c.writeI32(24);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
@@ -4187,7 +4900,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.PathUpgraded: {
-                    c.writeI32(24);
+                    c.writeI32(25);
                     const inner = value.inner;
                     FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -4198,7 +4911,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.HolePunchFailed: {
-                    c.writeI32(25);
+                    c.writeI32(26);
                     const inner = value.inner;
                     FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
                     FfiConverterUInt32.writeIntoCursor(inner.attempt, c);
@@ -4206,7 +4919,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.ConnectFailed: {
-                    c.writeI32(26);
+                    c.writeI32(27);
                     const inner = value.inner;
                     FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -4215,14 +4928,14 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.ConnectCancelled: {
-                    c.writeI32(27);
+                    c.writeI32(28);
                     const inner = value.inner;
                     FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     return;
                 }
                 case P2pEvent_Tags.InboundDirectUpgrade: {
-                    c.writeI32(28);
+                    c.writeI32(29);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterUInt64.writeIntoCursor(inner.oldConnId, c);
@@ -4230,7 +4943,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.Message: {
-                    c.writeI32(29);
+                    c.writeI32(30);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.fromPeerId, c);
                     FfiConverterSequenceString.writeIntoCursor(inner.topics, c);
@@ -4240,35 +4953,35 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.PeerSubscribed: {
-                    c.writeI32(30);
+                    c.writeI32(31);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterString.writeIntoCursor(inner.topic, c);
                     return;
                 }
                 case P2pEvent_Tags.PeerUnsubscribed: {
-                    c.writeI32(31);
+                    c.writeI32(32);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterString.writeIntoCursor(inner.topic, c);
                     return;
                 }
                 case P2pEvent_Tags.GossipsubOutboundFailure: {
-                    c.writeI32(32);
+                    c.writeI32(33);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterString.writeIntoCursor(inner.reason, c);
                     return;
                 }
                 case P2pEvent_Tags.GossipsubProtocolViolation: {
-                    c.writeI32(33);
+                    c.writeI32(34);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterString.writeIntoCursor(inner.reason, c);
                     return;
                 }
                 case P2pEvent_Tags.PeerDiscovered: {
-                    c.writeI32(34);
+                    c.writeI32(35);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
@@ -4276,7 +4989,7 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.PeerUpdated: {
-                    c.writeI32(35);
+                    c.writeI32(36);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
@@ -4284,31 +4997,31 @@ const FfiConverterTypeP2pEvent = (() => {
                     return;
                 }
                 case P2pEvent_Tags.PeerExpired: {
-                    c.writeI32(36);
+                    c.writeI32(37);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     return;
                 }
                 case P2pEvent_Tags.DiscoveryDialFailed: {
-                    c.writeI32(37);
+                    c.writeI32(38);
                     const inner = value.inner;
                     FfiConverterString.writeIntoCursor(inner.peerId, c);
                     FfiConverterString.writeIntoCursor(inner.reason, c);
                     return;
                 }
                 case P2pEvent_Tags.MdnsFailed: {
-                    c.writeI32(38);
+                    c.writeI32(39);
                     const inner = value.inner;
                     FfiConverterTypeMdnsFailureKind.writeIntoCursor(inner.kind, c);
                     FfiConverterString.writeIntoCursor(inner.detail, c);
                     return;
                 }
                 case P2pEvent_Tags.MdnsRecovered: {
-                    c.writeI32(39);
+                    c.writeI32(40);
                     return;
                 }
                 case P2pEvent_Tags.DiscoveryProtocolViolation: {
-                    c.writeI32(40);
+                    c.writeI32(41);
                     const inner = value.inner;
                     FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
                     FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
@@ -4469,6 +5182,12 @@ 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;
                     let size = 4;
@@ -4656,12 +5375,36 @@ const FfiConverterOptionalTypeDiscoveryOptions = new FfiConverterOptional(FfiCon
 // FfiConverter for MdnsOptions | undefined
 const FfiConverterOptionalTypeMdnsOptions = new FfiConverterOptional(FfiConverterTypeMdnsOptions);
 
-// FfiConverter for ArrayBuffer | undefined
-const FfiConverterOptionalBytes = new FfiConverterOptional(FfiConverterArrayBuffer);
-
 // FfiConverter for bigint | undefined
 const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
 
+// FfiConverter for boolean | undefined
+const FfiConverterOptionalBoolean = new FfiConverterOptional(FfiConverterBool);
+
+// FfiConverter for WindowLimit | undefined
+const FfiConverterOptionalTypeWindowLimit = new FfiConverterOptional(FfiConverterTypeWindowLimit);
+
+// FfiConverter for QuicLimitsOptions | undefined
+const FfiConverterOptionalTypeQuicLimitsOptions = new FfiConverterOptional(FfiConverterTypeQuicLimitsOptions);
+
+// FfiConverter for TimeoutLimit | undefined
+const FfiConverterOptionalTypeTimeoutLimit = new FfiConverterOptional(FfiConverterTypeTimeoutLimit);
+
+// FfiConverter for number | undefined
+const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
+
+// FfiConverter for YamuxOptions | undefined
+const FfiConverterOptionalTypeYamuxOptions = new FfiConverterOptional(FfiConverterTypeYamuxOptions);
+
+// FfiConverter for TcpLimitsOptions | undefined
+const FfiConverterOptionalTypeTcpLimitsOptions = new FfiConverterOptional(FfiConverterTypeTcpLimitsOptions);
+
+// FfiConverter for LimitsOptions | undefined
+const FfiConverterOptionalTypeLimitsOptions = new FfiConverterOptional(FfiConverterTypeLimitsOptions);
+
+// FfiConverter for ArrayBuffer | undefined
+const FfiConverterOptionalBytes = new FfiConverterOptional(FfiConverterArrayBuffer);
+
 // FfiConverter for Array<bigint>
 const FfiConverterSequenceUInt64 = new FfiConverterArray(FfiConverterUInt64);
 
@@ -4706,14 +5449,20 @@ export default Object.freeze({
     FfiConverterTypeFfiError,
     FfiConverterTypeIdentifyInfo,
     FfiConverterTypeKnownPeerInfo,
+    FfiConverterTypeLimitsOptions,
     FfiConverterTypeMdnsFailureKind,
     FfiConverterTypeMdnsOptions,
     FfiConverterTypeNatErrorKind,
     FfiConverterTypeOpenStreamResult,
     FfiConverterTypeP2pEvent,
     FfiConverterTypePathKind,
+    FfiConverterTypeQuicLimitsOptions,
     FfiConverterTypeReachability,
     FfiConverterTypeRelayReservationInfo,
+    FfiConverterTypeTcpLimitsOptions,
+    FfiConverterTypeTimeoutLimit,
     FfiConverterTypeUnfinishedConnection,
+    FfiConverterTypeWindowLimit,
+    FfiConverterTypeYamuxOptions,
   }
 });