@minip2p/react-native 0.11.0 → 0.11.2

package/src/generated/minip2p_ffi_core.ts

@@ -6,7 +6,7 @@
 import nativeModule from "./minip2p_ffi_core-ffi";
 import { type UniffiRustFutureContinuationCallback, type UniffiForeignFutureDroppedCallback, type UniffiForeignFutureDroppedCallbackStruct,
 } from "./minip2p_ffi_core-ffi";
-import { type UniffiByteArray, AbstractFfiConverterByteArray, Cursor, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, FfiConverterUInt8, RustBuffer, UniffiEnum, UniffiError, UniffiInternalError, UniffiRustCaller, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiTypeNameSymbol, variantOrdinalSymbol,
+import { type UniffiByteArray, AbstractFfiConverterByteArray, Cursor, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterFloat32, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, FfiConverterUInt8, RustBuffer, UniffiEnum, UniffiError, UniffiInternalError, UniffiRustCaller, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiTypeNameSymbol, variantOrdinalSymbol,
 } from "@ubjs/core";
 const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
 
@@ -611,6 +611,49 @@ const FfiConverterTypeWindowLimit = (() => {
     return new FFIConverter();
 })();
 
+/**
+ * A QUIC congestion controller; mirrors `minip2p::CongestionController`.
+ */
+export enum CongestionController {
+    /**
+     * CUBIC, the default.
+     */
+    Cubic,
+    /**
+     * NewReno.
+     */
+    NewReno,
+    /**
+     * BBR (experimental in quinn).
+     */
+    Bbr
+}
+
+const FfiConverterTypeCongestionController = (() => {
+    type TypeName = CongestionController;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return CongestionController.Cubic;
+                case 2: return CongestionController.NewReno;
+                case 3: return CongestionController.Bbr;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case CongestionController.Cubic: return c.writeI32(1);
+                case CongestionController.NewReno: return c.writeI32(2);
+                case CongestionController.Bbr: return c.writeI32(3);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
 /**
  * QUIC overrides; each field mirrors `minip2p::QuicLimits`.
  */
@@ -664,7 +707,21 @@ export type QuicLimitsOptions = {
      * Time an `h3` connection has to complete Noise, in milliseconds;
      * non-zero.
      */
-    webtransportHandshakeTimeoutMs?: bigint
+    webtransportHandshakeTimeoutMs?: bigint,
+    /**
+     * Congestion controller each connection runs (Cubic by default).
+     */
+    congestionController?: CongestionController,
+    /**
+     * Packets acknowledged past a missing one before it is declared lost;
+     * at least 3.
+     */
+    packetThreshold?: number,
+    /**
+     * Multiple of the RTT a missing packet may wait before it is declared
+     * lost; between 1.0 and 10.0.
+     */
+    timeThreshold?: number
 }
 
 /**
@@ -683,7 +740,10 @@ export const QuicLimitsOptions = (() => {
         streamReceiveWindow: undefined,
         connectionReceiveWindow: undefined,
         sendWindow: undefined,
-        webtransportHandshakeTimeoutMs: undefined
+        webtransportHandshakeTimeoutMs: undefined,
+        congestionController: undefined,
+        packetThreshold: undefined,
+        timeThreshold: undefined
     });
     const create = (() => {
         return uniffiCreateRecord<QuicLimitsOptions, ReturnType<typeof defaults>>(defaults);
@@ -711,7 +771,10 @@ const FfiConverterTypeQuicLimitsOptions = (() => {
                 streamReceiveWindow: FfiConverterOptionalUInt64.readFromCursor(c),
                 connectionReceiveWindow: FfiConverterOptionalTypeWindowLimit.readFromCursor(c),
                 sendWindow: FfiConverterOptionalUInt64.readFromCursor(c),
-                webtransportHandshakeTimeoutMs: FfiConverterOptionalUInt64.readFromCursor(c)
+                webtransportHandshakeTimeoutMs: FfiConverterOptionalUInt64.readFromCursor(c),
+                congestionController: FfiConverterOptionalTypeCongestionController.readFromCursor(c),
+                packetThreshold: FfiConverterOptionalUInt32.readFromCursor(c),
+                timeThreshold: FfiConverterOptionalFloat32.readFromCursor(c)
             };
         }
         writeIntoCursor(value: TypeName, c: Cursor): void {
@@ -727,6 +790,9 @@ const FfiConverterTypeQuicLimitsOptions = (() => {
             FfiConverterOptionalTypeWindowLimit.writeIntoCursor(value.connectionReceiveWindow, c);
             FfiConverterOptionalUInt64.writeIntoCursor(value.sendWindow, c);
             FfiConverterOptionalUInt64.writeIntoCursor(value.webtransportHandshakeTimeoutMs, c);
+            FfiConverterOptionalTypeCongestionController.writeIntoCursor(value.congestionController, c);
+            FfiConverterOptionalUInt32.writeIntoCursor(value.packetThreshold, c);
+            FfiConverterOptionalFloat32.writeIntoCursor(value.timeThreshold, c);
         }
         allocationSize(value: TypeName): number {
             return FfiConverterOptionalUInt64.allocationSize(value.maxConnections) +
@@ -740,7 +806,10 @@ const FfiConverterTypeQuicLimitsOptions = (() => {
              FfiConverterOptionalUInt64.allocationSize(value.streamReceiveWindow) +
              FfiConverterOptionalTypeWindowLimit.allocationSize(value.connectionReceiveWindow) +
              FfiConverterOptionalUInt64.allocationSize(value.sendWindow) +
-             FfiConverterOptionalUInt64.allocationSize(value.webtransportHandshakeTimeoutMs);
+             FfiConverterOptionalUInt64.allocationSize(value.webtransportHandshakeTimeoutMs) +
+             FfiConverterOptionalTypeCongestionController.allocationSize(value.congestionController) +
+             FfiConverterOptionalUInt32.allocationSize(value.packetThreshold) +
+             FfiConverterOptionalFloat32.allocationSize(value.timeThreshold);
 
         }
     };
@@ -1135,6 +1204,75 @@ const FfiConverterTypeLimitsOptions = (() => {
     return new FFIConverter();
 })();
 
+/**
+ * Protocol deadline overrides, in milliseconds; each mirrors a
+ * `minip2p::SwarmTimeouts` field.
+ *
+ * An absent record or field keeps the native default (10 s each). A zero
+ * fails construction with `InvalidConfig { capability: Options }`. Keep
+ * `identify_ms` at least `negotiation_ms`: the first Identify includes a
+ * negotiation.
+ */
+export type TimeoutsOptions = {
+    /**
+     * How long an outbound stream may negotiate its protocol.
+     */
+    negotiationMs?: bigint,
+    /**
+     * How long a connection's first Identify may take before the
+     * connection is closed.
+     */
+    identifyMs?: bigint,
+    /**
+     * How long a ping waits for its echo.
+     */
+    pingMs?: bigint
+}
+
+/**
+ * Generated factory for {@link TimeoutsOptions} record objects.
+ */
+export const TimeoutsOptions = (() => {
+    const defaults = () => ({
+        negotiationMs: undefined,
+        identifyMs: undefined,
+        pingMs: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<TimeoutsOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<TimeoutsOptions>,
+    });
+})();
+
+const FfiConverterTypeTimeoutsOptions = (() => {
+    type TypeName = TimeoutsOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                negotiationMs: FfiConverterOptionalUInt64.readFromCursor(c),
+                identifyMs: FfiConverterOptionalUInt64.readFromCursor(c),
+                pingMs: FfiConverterOptionalUInt64.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterOptionalUInt64.writeIntoCursor(value.negotiationMs, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.identifyMs, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(value.pingMs, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalUInt64.allocationSize(value.negotiationMs) +
+             FfiConverterOptionalUInt64.allocationSize(value.identifyMs) +
+             FfiConverterOptionalUInt64.allocationSize(value.pingMs);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
 /**
  * Configuration used to construct an FFI endpoint.
  */
@@ -1182,7 +1320,11 @@ export type EndpointConfig = {
     /**
      * Transport limit overrides, or every native default when absent.
      */
-    limits?: LimitsOptions
+    limits?: LimitsOptions,
+    /**
+     * Protocol deadline overrides, or every native default when absent.
+     */
+    timeouts?: TimeoutsOptions
 }
 
 /**
@@ -1215,7 +1357,8 @@ const FfiConverterTypeEndpointConfig = (() => {
                 protocols: FfiConverterSequenceString.readFromCursor(c),
                 discovery: FfiConverterOptionalTypeDiscoveryOptions.readFromCursor(c),
                 mdns: FfiConverterOptionalTypeMdnsOptions.readFromCursor(c),
-                limits: FfiConverterOptionalTypeLimitsOptions.readFromCursor(c)
+                limits: FfiConverterOptionalTypeLimitsOptions.readFromCursor(c),
+                timeouts: FfiConverterOptionalTypeTimeoutsOptions.readFromCursor(c)
             };
         }
         writeIntoCursor(value: TypeName, c: Cursor): void {
@@ -1229,6 +1372,7 @@ const FfiConverterTypeEndpointConfig = (() => {
             FfiConverterOptionalTypeDiscoveryOptions.writeIntoCursor(value.discovery, c);
             FfiConverterOptionalTypeMdnsOptions.writeIntoCursor(value.mdns, c);
             FfiConverterOptionalTypeLimitsOptions.writeIntoCursor(value.limits, c);
+            FfiConverterOptionalTypeTimeoutsOptions.writeIntoCursor(value.timeouts, c);
         }
         allocationSize(value: TypeName): number {
             return FfiConverterOptionalString.allocationSize(value.agentVersion) +
@@ -1240,7 +1384,8 @@ const FfiConverterTypeEndpointConfig = (() => {
              FfiConverterSequenceString.allocationSize(value.protocols) +
              FfiConverterOptionalTypeDiscoveryOptions.allocationSize(value.discovery) +
              FfiConverterOptionalTypeMdnsOptions.allocationSize(value.mdns) +
-             FfiConverterOptionalTypeLimitsOptions.allocationSize(value.limits);
+             FfiConverterOptionalTypeLimitsOptions.allocationSize(value.limits) +
+             FfiConverterOptionalTypeTimeoutsOptions.allocationSize(value.timeouts);
 
         }
     };
@@ -5384,15 +5529,21 @@ const FfiConverterOptionalBoolean = new FfiConverterOptional(FfiConverterBool);
 // FfiConverter for WindowLimit | undefined
 const FfiConverterOptionalTypeWindowLimit = new FfiConverterOptional(FfiConverterTypeWindowLimit);
 
+// FfiConverter for CongestionController | undefined
+const FfiConverterOptionalTypeCongestionController = new FfiConverterOptional(FfiConverterTypeCongestionController);
+
+// FfiConverter for number | undefined
+const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
+
+// FfiConverter for number | undefined
+const FfiConverterOptionalFloat32 = new FfiConverterOptional(FfiConverterFloat32);
+
 // 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);
 
@@ -5402,6 +5553,9 @@ const FfiConverterOptionalTypeTcpLimitsOptions = new FfiConverterOptional(FfiCon
 // FfiConverter for LimitsOptions | undefined
 const FfiConverterOptionalTypeLimitsOptions = new FfiConverterOptional(FfiConverterTypeLimitsOptions);
 
+// FfiConverter for TimeoutsOptions | undefined
+const FfiConverterOptionalTypeTimeoutsOptions = new FfiConverterOptional(FfiConverterTypeTimeoutsOptions);
+
 // FfiConverter for ArrayBuffer | undefined
 const FfiConverterOptionalBytes = new FfiConverterOptional(FfiConverterArrayBuffer);
 
@@ -5438,6 +5592,7 @@ export default Object.freeze({
   converters: {
     FfiConverterTypeCloseOutcome,
     FfiConverterTypeConfigCapability,
+    FfiConverterTypeCongestionController,
     FfiConverterTypeConnectTarget,
     FfiConverterTypeConnectionCloseReason,
     FfiConverterTypeConnectionInfo,
@@ -5461,6 +5616,7 @@ export default Object.freeze({
     FfiConverterTypeRelayReservationInfo,
     FfiConverterTypeTcpLimitsOptions,
     FfiConverterTypeTimeoutLimit,
+    FfiConverterTypeTimeoutsOptions,
     FfiConverterTypeUnfinishedConnection,
     FfiConverterTypeWindowLimit,
     FfiConverterTypeYamuxOptions,