@minip2p/react-native 0.10.1 → 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);
     }
   }
   ;
@@ -4062,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);
 
@@ -4109,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