@minip2p/react-native 0.10.0 → 0.10.2

package/lib/typescript/src/generated/minip2p_ffi_core.d.ts

@@ -213,6 +213,340 @@ export declare const MdnsOptions: Readonly<{
     new: (partial: Partial<MdnsOptions> & Required<Omit<MdnsOptions, never>>) => MdnsOptions;
     defaults: () => Partial<MdnsOptions>;
 }>;
+export declare enum WindowLimit_Tags {
+    Bounded = "Bounded",
+    Unlimited = "Unlimited"
+}
+/**
+ * A receive window that may be unbounded.
+ */
+export declare const WindowLimit: Readonly<{
+    instanceOf: (obj: any) => obj is WindowLimit;
+    Bounded: {
+        new (inner: {
+            bytes: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            bytes: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    Unlimited: {
+        new (): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "WindowLimit";
+            readonly tag: WindowLimit_Tags.Unlimited;
+        };
+        "new"(): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "WindowLimit";
+            readonly tag: WindowLimit_Tags.Unlimited;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "WindowLimit";
+            readonly tag: WindowLimit_Tags.Unlimited;
+        };
+    };
+}>;
+/**
+ * A receive window that may be unbounded.
+ */
+export type WindowLimit = InstanceType<typeof WindowLimit['Bounded' | 'Unlimited']>;
+/**
+ * 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 declare const QuicLimitsOptions: Readonly<{
+    create: (partial: Partial<QuicLimitsOptions> & Required<Omit<QuicLimitsOptions, "connectionReceiveWindow" | "controlStreamReserveBytes" | "idleTimeoutMs" | "maxConnections" | "maxPendingBytesPerStream" | "maxPendingConnectionBytes" | "maxPendingDatagrams" | "maxStreamsPerConnection" | "requireAddressValidation" | "sendWindow" | "streamReceiveWindow" | "webtransportHandshakeTimeoutMs">>) => QuicLimitsOptions;
+    new: (partial: Partial<QuicLimitsOptions> & Required<Omit<QuicLimitsOptions, "connectionReceiveWindow" | "controlStreamReserveBytes" | "idleTimeoutMs" | "maxConnections" | "maxPendingBytesPerStream" | "maxPendingConnectionBytes" | "maxPendingDatagrams" | "maxStreamsPerConnection" | "requireAddressValidation" | "sendWindow" | "streamReceiveWindow" | "webtransportHandshakeTimeoutMs">>) => QuicLimitsOptions;
+    defaults: () => Partial<QuicLimitsOptions>;
+}>;
+export declare enum TimeoutLimit_Tags {
+    AfterMs = "AfterMs",
+    Never = "Never"
+}
+/**
+ * A timeout that may be disabled.
+ */
+export declare const TimeoutLimit: Readonly<{
+    instanceOf: (obj: any) => obj is TimeoutLimit;
+    AfterMs: {
+        new (inner: {
+            ms: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        "new"(inner: {
+            ms: bigint;
+        }): {
+            /**
+             * @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;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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;
+            }>;
+        };
+    };
+    Never: {
+        new (): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TimeoutLimit";
+            readonly tag: TimeoutLimit_Tags.Never;
+        };
+        "new"(): {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TimeoutLimit";
+            readonly tag: TimeoutLimit_Tags.Never;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TimeoutLimit";
+            readonly tag: TimeoutLimit_Tags.Never;
+        };
+    };
+}>;
+/**
+ * A timeout that may be disabled.
+ */
+export type TimeoutLimit = InstanceType<typeof TimeoutLimit['AfterMs' | 'Never']>;
+/**
+ * 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 declare const YamuxOptions: Readonly<{
+    create: (partial: Partial<YamuxOptions> & Required<Omit<YamuxOptions, "controlStreamReserve" | "maxBufferedSend" | "maxFrameLen" | "maxPendingControl" | "maxStreams" | "maxTotalBufferedSend" | "receiveWindow">>) => YamuxOptions;
+    new: (partial: Partial<YamuxOptions> & Required<Omit<YamuxOptions, "controlStreamReserve" | "maxBufferedSend" | "maxFrameLen" | "maxPendingControl" | "maxStreams" | "maxTotalBufferedSend" | "receiveWindow">>) => YamuxOptions;
+    defaults: () => Partial<YamuxOptions>;
+}>;
+/**
+ * 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 declare const TcpLimitsOptions: Readonly<{
+    create: (partial: Partial<TcpLimitsOptions> & Required<Omit<TcpLimitsOptions, "handshakeTimeoutMs" | "maxBufferedSend" | "maxConnections" | "sendStallTimeoutMs" | "yamux">>) => TcpLimitsOptions;
+    new: (partial: Partial<TcpLimitsOptions> & Required<Omit<TcpLimitsOptions, "handshakeTimeoutMs" | "maxBufferedSend" | "maxConnections" | "sendStallTimeoutMs" | "yamux">>) => TcpLimitsOptions;
+    defaults: () => Partial<TcpLimitsOptions>;
+}>;
+/**
+ * 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 declare const LimitsOptions: Readonly<{
+    create: (partial: Partial<LimitsOptions> & Required<Omit<LimitsOptions, "circuit" | "maxCircuits" | "quic" | "tcp">>) => LimitsOptions;
+    new: (partial: Partial<LimitsOptions> & Required<Omit<LimitsOptions, "circuit" | "maxCircuits" | "quic" | "tcp">>) => LimitsOptions;
+    defaults: () => Partial<LimitsOptions>;
+}>;
 /**
  * Configuration used to construct an FFI endpoint.
  */
@@ -257,13 +591,17 @@ export type EndpointConfig = {
      * Local-link mDNS settings, or no mDNS discovery when absent.
      */
     mdns?: MdnsOptions;
+    /**
+     * Transport limit overrides, or every native default when absent.
+     */
+    limits?: LimitsOptions;
 };
 /**
  * Generated factory for {@link EndpointConfig} record objects.
  */
 export declare const EndpointConfig: Readonly<{
-    create: (partial: Partial<EndpointConfig> & Required<Omit<EndpointConfig, "agentVersion" | "discovery" | "listen" | "mdns">>) => EndpointConfig;
-    new: (partial: Partial<EndpointConfig> & Required<Omit<EndpointConfig, "agentVersion" | "discovery" | "listen" | "mdns">>) => EndpointConfig;
+    create: (partial: Partial<EndpointConfig> & Required<Omit<EndpointConfig, "agentVersion" | "discovery" | "limits" | "listen" | "mdns">>) => EndpointConfig;
+    new: (partial: Partial<EndpointConfig> & Required<Omit<EndpointConfig, "agentVersion" | "discovery" | "limits" | "listen" | "mdns">>) => EndpointConfig;
     defaults: () => Partial<EndpointConfig>;
 }>;
 /**
@@ -1887,6 +2225,7 @@ export declare enum P2pEvent_Tags {
     StreamClosed = "StreamClosed",
     EndpointError = "EndpointError",
     ReachabilityChanged = "ReachabilityChanged",
+    ListenAddressesChanged = "ListenAddressesChanged",
     PublicAddressesChanged = "PublicAddressesChanged",
     RelayReserved = "RelayReserved",
     RelayReservationLost = "RelayReservationLost",
@@ -2807,6 +3146,45 @@ export declare const P2pEvent: Readonly<{
             }>;
         };
     };
+    ListenAddressesChanged: {
+        new (inner: {
+            addrs: Array<string>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        "new"(inner: {
+            addrs: Array<string>;
+        }): {
+            /**
+             * @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>;
+            }>;
+        };
+        instanceOf(obj: any): obj is {
+            /**
+             * @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>;
+            }>;
+        };
+    };
     PublicAddressesChanged: {
         new (inner: {
             addrs: Array<string>;
@@ -3836,7 +4214,7 @@ export declare const P2pEvent: Readonly<{
 /**
  * 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']>;
+export type P2pEvent = InstanceType<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']>;
 /**
  * This should be called before anything else.
  *
@@ -3942,6 +4320,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): KnownPeerInfo;
             lower(value: KnownPeerInfo, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeLimitsOptions: {
+            readFromCursor(c: Cursor): LimitsOptions;
+            writeIntoCursor(value: LimitsOptions, c: Cursor): void;
+            allocationSize(value: LimitsOptions): number;
+            lift(value: UniffiByteArray): LimitsOptions;
+            lower(value: LimitsOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeMdnsFailureKind: {
             readFromCursor(c: Cursor): MdnsFailureKind;
             writeIntoCursor(value: MdnsFailureKind, c: Cursor): void;
@@ -3984,6 +4369,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): PathKind;
             lower(value: PathKind, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeQuicLimitsOptions: {
+            readFromCursor(c: Cursor): QuicLimitsOptions;
+            writeIntoCursor(value: QuicLimitsOptions, c: Cursor): void;
+            allocationSize(value: QuicLimitsOptions): number;
+            lift(value: UniffiByteArray): QuicLimitsOptions;
+            lower(value: QuicLimitsOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeReachability: {
             readFromCursor(c: Cursor): Reachability;
             writeIntoCursor(value: Reachability, c: Cursor): void;
@@ -3998,6 +4390,20 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): RelayReservationInfo;
             lower(value: RelayReservationInfo, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeTcpLimitsOptions: {
+            readFromCursor(c: Cursor): TcpLimitsOptions;
+            writeIntoCursor(value: TcpLimitsOptions, c: Cursor): void;
+            allocationSize(value: TcpLimitsOptions): number;
+            lift(value: UniffiByteArray): TcpLimitsOptions;
+            lower(value: TcpLimitsOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeTimeoutLimit: {
+            readFromCursor(c: Cursor): TimeoutLimit;
+            writeIntoCursor(value: TimeoutLimit, c: Cursor): void;
+            allocationSize(value: TimeoutLimit): number;
+            lift(value: UniffiByteArray): TimeoutLimit;
+            lower(value: TimeoutLimit, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
         FfiConverterTypeUnfinishedConnection: {
             readFromCursor(c: Cursor): UnfinishedConnection;
             writeIntoCursor(value: UnfinishedConnection, c: Cursor): void;
@@ -4005,6 +4411,20 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): UnfinishedConnection;
             lower(value: UnfinishedConnection, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
         };
+        FfiConverterTypeWindowLimit: {
+            readFromCursor(c: Cursor): WindowLimit;
+            writeIntoCursor(value: WindowLimit, c: Cursor): void;
+            allocationSize(value: WindowLimit): number;
+            lift(value: UniffiByteArray): WindowLimit;
+            lower(value: WindowLimit, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
+        FfiConverterTypeYamuxOptions: {
+            readFromCursor(c: Cursor): YamuxOptions;
+            writeIntoCursor(value: YamuxOptions, c: Cursor): void;
+            allocationSize(value: YamuxOptions): number;
+            lift(value: UniffiByteArray): YamuxOptions;
+            lower(value: YamuxOptions, alloc: import("@ubjs/core").RustBufferAllocator): UniffiByteArray;
+        };
     };
 }>;
 export default _default;