@minip2p/react-native 0.8.3 → 0.9.1

package/lib/module/generated/minip2p_ffi_core.js

@@ -408,6 +408,77 @@ const FfiConverterTypeRelayReservationInfo = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * The part of an endpoint's configuration an [`FfiError::InvalidConfig`]
+ * names.
+ *
+ * A configuration mistake is fixed by changing that part; an environment
+ * failure (a socket the platform refused) is [`FfiError::Transport`]
+ * instead.
+ */
+export let ConfigCapability = /*#__PURE__*/function (ConfigCapability) {
+  /**
+   * Gossipsub settings.
+   */
+  ConfigCapability[ConfigCapability["Gossipsub"] = 0] = "Gossipsub";
+  /**
+   * mDNS settings.
+   */
+  ConfigCapability[ConfigCapability["Mdns"] = 1] = "Mdns";
+  /**
+   * Signed discovery or peer-book settings.
+   */
+  ConfigCapability[ConfigCapability["Discovery"] = 2] = "Discovery";
+  /**
+   * QUIC or TCP transport settings (limits, TLS, the TCP namespace).
+   */
+  ConfigCapability[ConfigCapability["Transport"] = 3] = "Transport";
+  /**
+   * The endpoint's own options: listen addresses, protocols, NAT and
+   * relay policy, auto-dial.
+   */
+  ConfigCapability[ConfigCapability["Options"] = 4] = "Options";
+  return ConfigCapability;
+}({});
+const FfiConverterTypeConfigCapability = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return ConfigCapability.Gossipsub;
+        case 2:
+          return ConfigCapability.Mdns;
+        case 3:
+          return ConfigCapability.Discovery;
+        case 4:
+          return ConfigCapability.Transport;
+        case 5:
+          return ConfigCapability.Options;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case ConfigCapability.Gossipsub:
+          return c.writeI32(1);
+        case ConfigCapability.Mdns:
+          return c.writeI32(2);
+        case ConfigCapability.Discovery:
+          return c.writeI32(3);
+        case ConfigCapability.Transport:
+          return c.writeI32(4);
+        case ConfigCapability.Options:
+          return c.writeI32(5);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter();
+})();
+
 // Enum: ConnectTarget
 export let ConnectTarget_Tags = /*#__PURE__*/function (ConnectTarget_Tags) {
   ConnectTarget_Tags["Peer"] = "Peer";
@@ -798,7 +869,8 @@ export const FfiError = (() => {
     }
   }
   /**
-   * Endpoint configuration was internally inconsistent.
+   * Endpoint configuration was invalid; `capability` names the part of
+   * it that was.
    */
   class InvalidConfig_ extends UniffiError {
     /**
@@ -1006,7 +1078,8 @@ export const FfiError = (() => {
     }
   }
   /**
-   * A synchronous transport operation failed.
+   * A synchronous transport operation failed, or the platform refused a
+   * socket the endpoint needed (a port in use, say).
    */
   class Transport_ extends UniffiError {
     /**
@@ -1121,6 +1194,7 @@ const FfiConverterTypeFfiError = (() => {
           return new FfiError.Stopped();
         case 3:
           return new FfiError.InvalidConfig({
+            capability: FfiConverterTypeConfigCapability.readFromCursor(c),
             detail: FfiConverterString.readFromCursor(c)
           });
         case 4:
@@ -1179,6 +1253,7 @@ const FfiConverterTypeFfiError = (() => {
           {
             c.writeI32(3);
             const inner = value.inner;
+            FfiConverterTypeConfigCapability.writeIntoCursor(inner.capability, c);
             FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
@@ -1267,6 +1342,7 @@ const FfiConverterTypeFfiError = (() => {
           {
             const inner = value.inner;
             let size = 4;
+            size += FfiConverterTypeConfigCapability.allocationSize(inner.capability);
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
@@ -1342,6 +1418,88 @@ const FfiConverterTypeFfiError = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * Category of an mDNS failure.
+ */
+export let MdnsFailureKind = /*#__PURE__*/function (MdnsFailureKind) {
+  /**
+   * The platform cannot provide mDNS sockets.
+   */
+  MdnsFailureKind[MdnsFailureKind["Unsupported"] = 0] = "Unsupported";
+  /**
+   * An interface has no usable address.
+   */
+  MdnsFailureKind[MdnsFailureKind["NoInterfaceAddress"] = 1] = "NoInterfaceAddress";
+  /**
+   * A send named an interface that has gone away.
+   */
+  MdnsFailureKind[MdnsFailureKind["UnknownInterface"] = 2] = "UnknownInterface";
+  /**
+   * A goodbye could not be sent before shutdown gave up on a full send
+   * buffer.
+   */
+  MdnsFailureKind[MdnsFailureKind["Congested"] = 3] = "Congested";
+  /**
+   * A datagram is larger than the carrier can ever send.
+   */
+  MdnsFailureKind[MdnsFailureKind["Oversized"] = 4] = "Oversized";
+  /**
+   * The interface id space is exhausted.
+   */
+  MdnsFailureKind[MdnsFailureKind["InterfaceIdsExhausted"] = 5] = "InterfaceIdsExhausted";
+  /**
+   * Platform I/O failed.
+   */
+  MdnsFailureKind[MdnsFailureKind["Io"] = 6] = "Io";
+  return MdnsFailureKind;
+}({});
+const FfiConverterTypeMdnsFailureKind = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return MdnsFailureKind.Unsupported;
+        case 2:
+          return MdnsFailureKind.NoInterfaceAddress;
+        case 3:
+          return MdnsFailureKind.UnknownInterface;
+        case 4:
+          return MdnsFailureKind.Congested;
+        case 5:
+          return MdnsFailureKind.Oversized;
+        case 6:
+          return MdnsFailureKind.InterfaceIdsExhausted;
+        case 7:
+          return MdnsFailureKind.Io;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case MdnsFailureKind.Unsupported:
+          return c.writeI32(1);
+        case MdnsFailureKind.NoInterfaceAddress:
+          return c.writeI32(2);
+        case MdnsFailureKind.UnknownInterface:
+          return c.writeI32(3);
+        case MdnsFailureKind.Congested:
+          return c.writeI32(4);
+        case MdnsFailureKind.Oversized:
+          return c.writeI32(5);
+        case MdnsFailureKind.InterfaceIdsExhausted:
+          return c.writeI32(6);
+        case MdnsFailureKind.Io:
+          return c.writeI32(7);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter();
+})();
+
 /**
  * Category of a failed NAT connection attempt.
  */
@@ -1646,6 +1804,8 @@ export let P2pEvent_Tags = /*#__PURE__*/function (P2pEvent_Tags) {
   P2pEvent_Tags["PeerUpdated"] = "PeerUpdated";
   P2pEvent_Tags["PeerExpired"] = "PeerExpired";
   P2pEvent_Tags["DiscoveryDialFailed"] = "DiscoveryDialFailed";
+  P2pEvent_Tags["MdnsFailed"] = "MdnsFailed";
+  P2pEvent_Tags["MdnsRecovered"] = "MdnsRecovered";
   P2pEvent_Tags["DiscoveryProtocolViolation"] = "DiscoveryProtocolViolation";
   return P2pEvent_Tags;
 }({});
@@ -2422,6 +2582,50 @@ export const P2pEvent = (() => {
       return obj.tag === P2pEvent_Tags.DiscoveryDialFailed;
     }
   }
+  /**
+   * mDNS hit a hard failure. mDNS keeps running and retries; reported
+   * once per change in failure state, and followed by `MdnsRecovered`
+   * once a retry succeeds. A goodbye that failed during shutdown is
+   * final.
+   */
+  class MdnsFailed_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.MdnsFailed;
+    constructor(inner) {
+      super("P2pEvent", "MdnsFailed");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new MdnsFailed_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.MdnsFailed;
+    }
+  }
+  /**
+   * mDNS recovered from its last `MdnsFailed`.
+   */
+  class MdnsRecovered_ extends UniffiEnum {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "P2pEvent";
+    tag = P2pEvent_Tags.MdnsRecovered;
+    constructor() {
+      super("P2pEvent", "MdnsRecovered");
+    }
+    static new() {
+      return new MdnsRecovered_();
+    }
+    static instanceOf(obj) {
+      return obj.tag === P2pEvent_Tags.MdnsRecovered;
+    }
+  }
   /**
    * A discovery source supplied an invalid claim.
    */
@@ -2484,6 +2688,8 @@ export const P2pEvent = (() => {
     PeerUpdated: PeerUpdated_,
     PeerExpired: PeerExpired_,
     DiscoveryDialFailed: DiscoveryDialFailed_,
+    MdnsFailed: MdnsFailed_,
+    MdnsRecovered: MdnsRecovered_,
     DiscoveryProtocolViolation: DiscoveryProtocolViolation_
   });
 })();
@@ -2709,6 +2915,13 @@ const FfiConverterTypeP2pEvent = (() => {
             reason: FfiConverterString.readFromCursor(c)
           });
         case 37:
+          return new P2pEvent.MdnsFailed({
+            kind: FfiConverterTypeMdnsFailureKind.readFromCursor(c),
+            detail: FfiConverterString.readFromCursor(c)
+          });
+        case 38:
+          return new P2pEvent.MdnsRecovered();
+        case 39:
           return new P2pEvent.DiscoveryProtocolViolation({
             peerId: FfiConverterOptionalString.readFromCursor(c),
             source: FfiConverterTypeDiscoverySource.readFromCursor(c),
@@ -3041,10 +3254,23 @@ const FfiConverterTypeP2pEvent = (() => {
             FfiConverterString.writeIntoCursor(inner.reason, c);
             return;
           }
-        case P2pEvent_Tags.DiscoveryProtocolViolation:
+        case P2pEvent_Tags.MdnsFailed:
           {
             c.writeI32(37);
             const inner = value.inner;
+            FfiConverterTypeMdnsFailureKind.writeIntoCursor(inner.kind, c);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
+            return;
+          }
+        case P2pEvent_Tags.MdnsRecovered:
+          {
+            c.writeI32(38);
+            return;
+          }
+        case P2pEvent_Tags.DiscoveryProtocolViolation:
+          {
+            c.writeI32(39);
+            const inner = value.inner;
             FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
             FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
             FfiConverterString.writeIntoCursor(inner.reason, c);
@@ -3378,6 +3604,18 @@ const FfiConverterTypeP2pEvent = (() => {
             size += FfiConverterString.allocationSize(inner.reason);
             return size;
           }
+        case P2pEvent_Tags.MdnsFailed:
+          {
+            const inner = value.inner;
+            let size = 4;
+            size += FfiConverterTypeMdnsFailureKind.allocationSize(inner.kind);
+            size += FfiConverterString.allocationSize(inner.detail);
+            return size;
+          }
+        case P2pEvent_Tags.MdnsRecovered:
+          {
+            return 4;
+          }
         case P2pEvent_Tags.DiscoveryProtocolViolation:
           {
             const inner = value.inner;
@@ -3442,6 +3680,7 @@ function uniffiEnsureInitialized() {
 export default Object.freeze({
   initialize: uniffiEnsureInitialized,
   converters: {
+    FfiConverterTypeConfigCapability,
     FfiConverterTypeConnectTarget,
     FfiConverterTypeConnectionInfo,
     FfiConverterTypeDiscoveryOptions,
@@ -3452,6 +3691,7 @@ export default Object.freeze({
     FfiConverterTypeFfiError,
     FfiConverterTypeIdentifyInfo,
     FfiConverterTypeKnownPeerInfo,
+    FfiConverterTypeMdnsFailureKind,
     FfiConverterTypeMdnsOptions,
     FfiConverterTypeNatErrorKind,
     FfiConverterTypeOpenStreamResult,