@minip2p/react-native 0.10.0 → 0.10.2

package/lib/module/generated/minip2p_ffi_core.js

@@ -343,6 +343,475 @@ const FfiConverterTypeMdnsOptions = (() => {
   return new FFIConverter();
 })();
 
+// Enum: WindowLimit
+export let WindowLimit_Tags = /*#__PURE__*/function (WindowLimit_Tags) {
+  WindowLimit_Tags["Bounded"] = "Bounded";
+  WindowLimit_Tags["Unlimited"] = "Unlimited";
+  return WindowLimit_Tags;
+}({});
+/**
+ * A receive window that may be unbounded.
+ */
+export const WindowLimit = (() => {
+  /**
+   * At most `bytes`.
+   */
+  class Bounded_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "WindowLimit";
+    tag = WindowLimit_Tags.Bounded;
+    constructor(inner) {
+      super("WindowLimit", "Bounded");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Bounded_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === WindowLimit_Tags.Bounded;
+    }
+  }
+  /**
+   * No window.
+   */
+  class Unlimited_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "WindowLimit";
+    tag = WindowLimit_Tags.Unlimited;
+    constructor() {
+      super("WindowLimit", "Unlimited");
+    }
+    static new() {
+      return new Unlimited_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === WindowLimit_Tags.Unlimited;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "WindowLimit";
+  }
+  return Object.freeze({
+    instanceOf,
+    Bounded: Bounded_,
+    Unlimited: Unlimited_
+  });
+})();
+/**
+ * A receive window that may be unbounded.
+ */
+
+// FfiConverter for enum WindowLimit
+const FfiConverterTypeWindowLimit = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      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, c) {
+      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) {
+      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`.
+ */
+
+/**
+ * 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(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeQuicLimitsOptions = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      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, c) {
+      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) {
+      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 let TimeoutLimit_Tags = /*#__PURE__*/function (TimeoutLimit_Tags) {
+  TimeoutLimit_Tags["AfterMs"] = "AfterMs";
+  TimeoutLimit_Tags["Never"] = "Never";
+  return TimeoutLimit_Tags;
+}({});
+/**
+ * A timeout that may be disabled.
+ */
+export const TimeoutLimit = (() => {
+  /**
+   * Fires after `ms` milliseconds.
+   */
+  class AfterMs_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "TimeoutLimit";
+    tag = TimeoutLimit_Tags.AfterMs;
+    constructor(inner) {
+      super("TimeoutLimit", "AfterMs");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new AfterMs_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === TimeoutLimit_Tags.AfterMs;
+    }
+  }
+  /**
+   * Waits indefinitely.
+   */
+  class Never_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "TimeoutLimit";
+    tag = TimeoutLimit_Tags.Never;
+    constructor() {
+      super("TimeoutLimit", "Never");
+    }
+    static new() {
+      return new Never_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === TimeoutLimit_Tags.Never;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "TimeoutLimit";
+  }
+  return Object.freeze({
+    instanceOf,
+    AfterMs: AfterMs_,
+    Never: Never_
+  });
+})();
+/**
+ * A timeout that may be disabled.
+ */
+
+// FfiConverter for enum TimeoutLimit
+const FfiConverterTypeTimeoutLimit = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      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, c) {
+      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) {
+      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`.
+ */
+
+/**
+ * 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(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeYamuxOptions = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      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, c) {
+      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) {
+      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).
+ */
+
+/**
+ * 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(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeTcpLimitsOptions = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        maxConnections: FfiConverterOptionalUInt64.readFromCursor(c),
+        handshakeTimeoutMs: FfiConverterOptionalTypeTimeoutLimit.readFromCursor(c),
+        maxBufferedSend: FfiConverterOptionalUInt64.readFromCursor(c),
+        sendStallTimeoutMs: FfiConverterOptionalTypeTimeoutLimit.readFromCursor(c),
+        yamux: FfiConverterOptionalTypeYamuxOptions.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      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) {
+      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 }`.
+ */
+
+/**
+ * Generated factory for {@link LimitsOptions} record objects.
+ */
+export const LimitsOptions = (() => {
+  const defaults = () => ({
+    quic: undefined,
+    tcp: undefined,
+    circuit: undefined,
+    maxCircuits: undefined
+  });
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeLimitsOptions = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        quic: FfiConverterOptionalTypeQuicLimitsOptions.readFromCursor(c),
+        tcp: FfiConverterOptionalTypeTcpLimitsOptions.readFromCursor(c),
+        circuit: FfiConverterOptionalTypeYamuxOptions.readFromCursor(c),
+        maxCircuits: FfiConverterOptionalUInt64.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterOptionalTypeQuicLimitsOptions.writeIntoCursor(value.quic, c);
+      FfiConverterOptionalTypeTcpLimitsOptions.writeIntoCursor(value.tcp, c);
+      FfiConverterOptionalTypeYamuxOptions.writeIntoCursor(value.circuit, c);
+      FfiConverterOptionalUInt64.writeIntoCursor(value.maxCircuits, c);
+    }
+    allocationSize(value) {
+      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.
  */
@@ -373,7 +842,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, c) {
@@ -386,9 +856,10 @@ const FfiConverterTypeEndpointConfig = (() => {
       FfiConverterSequenceString.writeIntoCursor(value.protocols, c);
       FfiConverterOptionalTypeDiscoveryOptions.writeIntoCursor(value.discovery, c);
       FfiConverterOptionalTypeMdnsOptions.writeIntoCursor(value.mdns, c);
+      FfiConverterOptionalTypeLimitsOptions.writeIntoCursor(value.limits, c);
     }
     allocationSize(value) {
-      return FfiConverterOptionalString.allocationSize(value.agentVersion) + FfiConverterSequenceString.allocationSize(value.relays) + FfiConverterSequenceString.allocationSize(value.autonatServers) + FfiConverterOptionalSequenceString.allocationSize(value.listen) + FfiConverterBool.allocationSize(value.forceRelay) + FfiConverterBool.allocationSize(value.allowUnsigned) + FfiConverterSequenceString.allocationSize(value.protocols) + FfiConverterOptionalTypeDiscoveryOptions.allocationSize(value.discovery) + FfiConverterOptionalTypeMdnsOptions.allocationSize(value.mdns);
+      return FfiConverterOptionalString.allocationSize(value.agentVersion) + FfiConverterSequenceString.allocationSize(value.relays) + FfiConverterSequenceString.allocationSize(value.autonatServers) + FfiConverterOptionalSequenceString.allocationSize(value.listen) + FfiConverterBool.allocationSize(value.forceRelay) + FfiConverterBool.allocationSize(value.allowUnsigned) + FfiConverterSequenceString.allocationSize(value.protocols) + FfiConverterOptionalTypeDiscoveryOptions.allocationSize(value.discovery) + FfiConverterOptionalTypeMdnsOptions.allocationSize(value.mdns) + FfiConverterOptionalTypeLimitsOptions.allocationSize(value.limits);
     }
   }
   ;
@@ -2106,6 +2577,7 @@ export let P2pEvent_Tags = /*#__PURE__*/function (P2pEvent_Tags) {
   P2pEvent_Tags["StreamClosed"] = "StreamClosed";
   P2pEvent_Tags["EndpointError"] = "EndpointError";
   P2pEvent_Tags["ReachabilityChanged"] = "ReachabilityChanged";
+  P2pEvent_Tags["ListenAddressesChanged"] = "ListenAddressesChanged";
   P2pEvent_Tags["PublicAddressesChanged"] = "PublicAddressesChanged";
   P2pEvent_Tags["RelayReserved"] = "RelayReserved";
   P2pEvent_Tags["RelayReservationLost"] = "RelayReservationLost";
@@ -2521,6 +2993,30 @@ export const P2pEvent = (() => {
       return obj.tag === P2pEvent_Tags.ReachabilityChanged;
     }
   }
+  /**
+   * The listen set changed without a `listen` call, as when a
+   * WebTransport listener's certificate rotates: `addrs` is the whole new
+   * set, with `/p2p/<local>`, for the app to republish. External and
+   * public address changes never fire it.
+   */
+  class ListenAddressesChanged_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.ListenAddressesChanged;
+    constructor(inner) {
+      super("P2pEvent", "ListenAddressesChanged");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new ListenAddressesChanged_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.ListenAddressesChanged;
+    }
+  }
   /**
    * AutoNAT confirmed a changed public address set.
    */
@@ -3014,6 +3510,7 @@ export const P2pEvent = (() => {
     StreamClosed: StreamClosed_,
     EndpointError: EndpointError_,
     ReachabilityChanged: ReachabilityChanged_,
+    ListenAddressesChanged: ListenAddressesChanged_,
     PublicAddressesChanged: PublicAddressesChanged_,
     RelayReserved: RelayReserved_,
     RelayReservationLost: RelayReservationLost_,
@@ -3158,32 +3655,36 @@ const FfiConverterTypeP2pEvent = (() => {
             confirmedAddrs: FfiConverterSequenceString.readFromCursor(c)
           });
         case 19:
-          return new P2pEvent.PublicAddressesChanged({
+          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 21:
+        case 22:
           return new P2pEvent.RelayReservationLost({
             relayPeerId: FfiConverterString.readFromCursor(c)
           });
-        case 22:
+        case 23:
           return new P2pEvent.PathEstablished({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c),
             path: FfiConverterTypePathKind.readFromCursor(c)
           });
-        case 23:
+        case 24:
           return new P2pEvent.InboundPathEstablished({
             peerId: FfiConverterString.readFromCursor(c),
             path: FfiConverterTypePathKind.readFromCursor(c),
             connId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 24:
+        case 25:
           return new P2pEvent.PathUpgraded({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c),
@@ -3192,31 +3693,31 @@ const FfiConverterTypeP2pEvent = (() => {
             oldConnId: FfiConverterUInt64.readFromCursor(c),
             newConnId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 25:
+        case 26:
           return new P2pEvent.HolePunchFailed({
             connectId: FfiConverterUInt64.readFromCursor(c),
             attempt: FfiConverterUInt32.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 26:
+        case 27:
           return new P2pEvent.ConnectFailed({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c),
             kind: FfiConverterTypeNatErrorKind.readFromCursor(c),
             detail: FfiConverterString.readFromCursor(c)
           });
-        case 27:
+        case 28:
           return new P2pEvent.ConnectCancelled({
             connectId: FfiConverterUInt64.readFromCursor(c),
             peerId: FfiConverterString.readFromCursor(c)
           });
-        case 28:
+        case 29:
           return new P2pEvent.InboundDirectUpgrade({
             peerId: FfiConverterString.readFromCursor(c),
             oldConnId: FfiConverterUInt64.readFromCursor(c),
             newConnId: FfiConverterUInt64.readFromCursor(c)
           });
-        case 29:
+        case 30:
           return new P2pEvent.Message({
             fromPeerId: FfiConverterString.readFromCursor(c),
             topics: FfiConverterSequenceString.readFromCursor(c),
@@ -3224,55 +3725,55 @@ const FfiConverterTypeP2pEvent = (() => {
             seqno: FfiConverterArrayBuffer.readFromCursor(c),
             signed: FfiConverterBool.readFromCursor(c)
           });
-        case 30:
+        case 31:
           return new P2pEvent.PeerSubscribed({
             peerId: FfiConverterString.readFromCursor(c),
             topic: FfiConverterString.readFromCursor(c)
           });
-        case 31:
+        case 32:
           return new P2pEvent.PeerUnsubscribed({
             peerId: FfiConverterString.readFromCursor(c),
             topic: FfiConverterString.readFromCursor(c)
           });
-        case 32:
+        case 33:
           return new P2pEvent.GossipsubOutboundFailure({
             peerId: FfiConverterString.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 33:
+        case 34:
           return new P2pEvent.GossipsubProtocolViolation({
             peerId: FfiConverterString.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 34:
+        case 35:
           return new P2pEvent.PeerDiscovered({
             peerId: FfiConverterString.readFromCursor(c),
             addrs: FfiConverterSequenceString.readFromCursor(c),
             source: FfiConverterTypeDiscoverySource.readFromCursor(c)
           });
-        case 35:
+        case 36:
           return new P2pEvent.PeerUpdated({
             peerId: FfiConverterString.readFromCursor(c),
             addrs: FfiConverterSequenceString.readFromCursor(c),
             source: FfiConverterTypeDiscoverySource.readFromCursor(c)
           });
-        case 36:
+        case 37:
           return new P2pEvent.PeerExpired({
             peerId: FfiConverterString.readFromCursor(c)
           });
-        case 37:
+        case 38:
           return new P2pEvent.DiscoveryDialFailed({
             peerId: FfiConverterString.readFromCursor(c),
             reason: FfiConverterString.readFromCursor(c)
           });
-        case 38:
+        case 39:
           return new P2pEvent.MdnsFailed({
             kind: FfiConverterTypeMdnsFailureKind.readFromCursor(c),
             detail: FfiConverterString.readFromCursor(c)
           });
-        case 39:
-          return new P2pEvent.MdnsRecovered();
         case 40:
+          return new P2pEvent.MdnsRecovered();
+        case 41:
           return new P2pEvent.DiscoveryProtocolViolation({
             peerId: FfiConverterOptionalString.readFromCursor(c),
             source: FfiConverterTypeDiscoverySource.readFromCursor(c),
@@ -3449,31 +3950,38 @@ 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);
@@ -3483,7 +3991,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.InboundPathEstablished:
           {
-            c.writeI32(23);
+            c.writeI32(24);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
@@ -3492,7 +4000,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PathUpgraded:
           {
-            c.writeI32(24);
+            c.writeI32(25);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -3504,7 +4012,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.HolePunchFailed:
           {
-            c.writeI32(25);
+            c.writeI32(26);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterUInt32.writeIntoCursor(inner.attempt, c);
@@ -3513,7 +4021,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.ConnectFailed:
           {
-            c.writeI32(26);
+            c.writeI32(27);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -3523,7 +4031,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.ConnectCancelled:
           {
-            c.writeI32(27);
+            c.writeI32(28);
             const inner = value.inner;
             FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
             FfiConverterString.writeIntoCursor(inner.peerId, c);
@@ -3531,7 +4039,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.InboundDirectUpgrade:
           {
-            c.writeI32(28);
+            c.writeI32(29);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterUInt64.writeIntoCursor(inner.oldConnId, c);
@@ -3540,7 +4048,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.Message:
           {
-            c.writeI32(29);
+            c.writeI32(30);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.fromPeerId, c);
             FfiConverterSequenceString.writeIntoCursor(inner.topics, c);
@@ -3551,7 +4059,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerSubscribed:
           {
-            c.writeI32(30);
+            c.writeI32(31);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.topic, c);
@@ -3559,7 +4067,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerUnsubscribed:
           {
-            c.writeI32(31);
+            c.writeI32(32);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.topic, c);
@@ -3567,7 +4075,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.GossipsubOutboundFailure:
           {
-            c.writeI32(32);
+            c.writeI32(33);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.reason, c);
@@ -3575,7 +4083,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.GossipsubProtocolViolation:
           {
-            c.writeI32(33);
+            c.writeI32(34);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterString.writeIntoCursor(inner.reason, c);
@@ -3583,7 +4091,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerDiscovered:
           {
-            c.writeI32(34);
+            c.writeI32(35);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
@@ -3592,7 +4100,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.PeerUpdated:
           {
-            c.writeI32(35);
+            c.writeI32(36);
             const inner = value.inner;
             FfiConverterString.writeIntoCursor(inner.peerId, c);
             FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
@@ -3601,14 +4109,14 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         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);
@@ -3616,7 +4124,7 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         case P2pEvent_Tags.MdnsFailed:
           {
-            c.writeI32(38);
+            c.writeI32(39);
             const inner = value.inner;
             FfiConverterTypeMdnsFailureKind.writeIntoCursor(inner.kind, c);
             FfiConverterString.writeIntoCursor(inner.detail, c);
@@ -3624,12 +4132,12 @@ const FfiConverterTypeP2pEvent = (() => {
           }
         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);
@@ -3808,6 +4316,13 @@ const FfiConverterTypeP2pEvent = (() => {
             size += FfiConverterSequenceString.allocationSize(inner.confirmedAddrs);
             return size;
           }
+        case P2pEvent_Tags.ListenAddressesChanged:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterSequenceString.allocationSize(inner.addrs);
+            return size;
+          }
         case P2pEvent_Tags.PublicAddressesChanged:
           {
             const inner = value.inner;
@@ -4018,12 +4533,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);
 
@@ -4065,15 +4604,21 @@ export default Object.freeze({
     FfiConverterTypeFfiError,
     FfiConverterTypeIdentifyInfo,
     FfiConverterTypeKnownPeerInfo,
+    FfiConverterTypeLimitsOptions,
     FfiConverterTypeMdnsFailureKind,
     FfiConverterTypeMdnsOptions,
     FfiConverterTypeNatErrorKind,
     FfiConverterTypeOpenStreamResult,
     FfiConverterTypeP2pEvent,
     FfiConverterTypePathKind,
+    FfiConverterTypeQuicLimitsOptions,
     FfiConverterTypeReachability,
     FfiConverterTypeRelayReservationInfo,
-    FfiConverterTypeUnfinishedConnection
+    FfiConverterTypeTcpLimitsOptions,
+    FfiConverterTypeTimeoutLimit,
+    FfiConverterTypeUnfinishedConnection,
+    FfiConverterTypeWindowLimit,
+    FfiConverterTypeYamuxOptions
   }
 });
 //# sourceMappingURL=minip2p_ffi_core.js.map