web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/@libp2p/circuit-relay-v2/dist/src/pb/index.js

@@ -0,0 +1,584 @@
+import { MaxLengthError } from '../../../../../protons-runtime/dist/src/index.js';
+import { alloc } from '../../../../../uint8arrays/dist/src/alloc.js';
+import { enumeration } from '../../../../../protons-runtime/dist/src/codecs/enum.js';
+import { message } from '../../../../../protons-runtime/dist/src/codecs/message.js';
+import { encodeMessage } from '../../../../../protons-runtime/dist/src/encode.js';
+import { decodeMessage } from '../../../../../protons-runtime/dist/src/decode.js';
+
+var HopMessage;
+(function (HopMessage) {
+  (function (Type) {
+    Type["RESERVE"] = "RESERVE";
+    Type["CONNECT"] = "CONNECT";
+    Type["STATUS"] = "STATUS";
+  })(HopMessage.Type || (HopMessage.Type = {}));
+  let __TypeValues;
+  (function (__TypeValues) {
+    __TypeValues[__TypeValues["RESERVE"] = 0] = "RESERVE";
+    __TypeValues[__TypeValues["CONNECT"] = 1] = "CONNECT";
+    __TypeValues[__TypeValues["STATUS"] = 2] = "STATUS";
+  })(__TypeValues || (__TypeValues = {}));
+  (function (Type) {
+    Type.codec = () => {
+      return enumeration(__TypeValues);
+    };
+  })(HopMessage.Type || (HopMessage.Type = {}));
+  let _codec;
+  HopMessage.codec = () => {
+    if (_codec == null) {
+      _codec = message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.type != null) {
+          w.uint32(8);
+          HopMessage.Type.codec().encode(obj.type, w);
+        }
+        if (obj.peer != null) {
+          w.uint32(18);
+          Peer.codec().encode(obj.peer, w);
+        }
+        if (obj.reservation != null) {
+          w.uint32(26);
+          Reservation.codec().encode(obj.reservation, w);
+        }
+        if (obj.limit != null) {
+          w.uint32(34);
+          Limit.codec().encode(obj.limit, w);
+        }
+        if (obj.status != null) {
+          w.uint32(40);
+          Status.codec().encode(obj.status, w);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {};
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.type = HopMessage.Type.codec().decode(reader);
+                break;
+              }
+            case 2:
+              {
+                obj.peer = Peer.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.peer
+                });
+                break;
+              }
+            case 3:
+              {
+                obj.reservation = Reservation.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.reservation
+                });
+                break;
+              }
+            case 4:
+              {
+                obj.limit = Limit.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.limit
+                });
+                break;
+              }
+            case 5:
+              {
+                obj.status = Status.codec().decode(reader);
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  HopMessage.encode = obj => {
+    return encodeMessage(obj, HopMessage.codec());
+  };
+  HopMessage.decode = (buf, opts) => {
+    return decodeMessage(buf, HopMessage.codec(), opts);
+  };
+})(HopMessage || (HopMessage = {}));
+var StopMessage;
+(function (StopMessage) {
+  (function (Type) {
+    Type["CONNECT"] = "CONNECT";
+    Type["STATUS"] = "STATUS";
+  })(StopMessage.Type || (StopMessage.Type = {}));
+  let __TypeValues;
+  (function (__TypeValues) {
+    __TypeValues[__TypeValues["CONNECT"] = 0] = "CONNECT";
+    __TypeValues[__TypeValues["STATUS"] = 1] = "STATUS";
+  })(__TypeValues || (__TypeValues = {}));
+  (function (Type) {
+    Type.codec = () => {
+      return enumeration(__TypeValues);
+    };
+  })(StopMessage.Type || (StopMessage.Type = {}));
+  let _codec;
+  StopMessage.codec = () => {
+    if (_codec == null) {
+      _codec = message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.type != null) {
+          w.uint32(8);
+          StopMessage.Type.codec().encode(obj.type, w);
+        }
+        if (obj.peer != null) {
+          w.uint32(18);
+          Peer.codec().encode(obj.peer, w);
+        }
+        if (obj.limit != null) {
+          w.uint32(26);
+          Limit.codec().encode(obj.limit, w);
+        }
+        if (obj.status != null) {
+          w.uint32(32);
+          Status.codec().encode(obj.status, w);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {};
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.type = StopMessage.Type.codec().decode(reader);
+                break;
+              }
+            case 2:
+              {
+                obj.peer = Peer.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.peer
+                });
+                break;
+              }
+            case 3:
+              {
+                obj.limit = Limit.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.limit
+                });
+                break;
+              }
+            case 4:
+              {
+                obj.status = Status.codec().decode(reader);
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  StopMessage.encode = obj => {
+    return encodeMessage(obj, StopMessage.codec());
+  };
+  StopMessage.decode = (buf, opts) => {
+    return decodeMessage(buf, StopMessage.codec(), opts);
+  };
+})(StopMessage || (StopMessage = {}));
+var Peer;
+(function (Peer) {
+  let _codec;
+  Peer.codec = () => {
+    if (_codec == null) {
+      _codec = message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.id != null && obj.id.byteLength > 0) {
+          w.uint32(10);
+          w.bytes(obj.id);
+        }
+        if (obj.addrs != null) {
+          for (const value of obj.addrs) {
+            w.uint32(18);
+            w.bytes(value);
+          }
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {
+          id: alloc(0),
+          addrs: []
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.id = reader.bytes();
+                break;
+              }
+            case 2:
+              {
+                if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
+                  throw new MaxLengthError('Decode error - map field "addrs" had too many elements');
+                }
+                obj.addrs.push(reader.bytes());
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  Peer.encode = obj => {
+    return encodeMessage(obj, Peer.codec());
+  };
+  Peer.decode = (buf, opts) => {
+    return decodeMessage(buf, Peer.codec(), opts);
+  };
+})(Peer || (Peer = {}));
+var Reservation;
+(function (Reservation) {
+  let _codec;
+  Reservation.codec = () => {
+    if (_codec == null) {
+      _codec = message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.expire != null && obj.expire !== 0n) {
+          w.uint32(8);
+          w.uint64(obj.expire);
+        }
+        if (obj.addrs != null) {
+          for (const value of obj.addrs) {
+            w.uint32(18);
+            w.bytes(value);
+          }
+        }
+        if (obj.voucher != null) {
+          w.uint32(26);
+          Envelope.codec().encode(obj.voucher, w);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {
+          expire: 0n,
+          addrs: []
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.expire = reader.uint64();
+                break;
+              }
+            case 2:
+              {
+                if (opts.limits?.addrs != null && obj.addrs.length === opts.limits.addrs) {
+                  throw new MaxLengthError('Decode error - map field "addrs" had too many elements');
+                }
+                obj.addrs.push(reader.bytes());
+                break;
+              }
+            case 3:
+              {
+                obj.voucher = Envelope.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.voucher
+                });
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  Reservation.encode = obj => {
+    return encodeMessage(obj, Reservation.codec());
+  };
+  Reservation.decode = (buf, opts) => {
+    return decodeMessage(buf, Reservation.codec(), opts);
+  };
+})(Reservation || (Reservation = {}));
+var Limit;
+(function (Limit) {
+  let _codec;
+  Limit.codec = () => {
+    if (_codec == null) {
+      _codec = message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.duration != null) {
+          w.uint32(8);
+          w.uint32(obj.duration);
+        }
+        if (obj.data != null) {
+          w.uint32(16);
+          w.uint64(obj.data);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        const obj = {};
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.duration = reader.uint32();
+                break;
+              }
+            case 2:
+              {
+                obj.data = reader.uint64();
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  Limit.encode = obj => {
+    return encodeMessage(obj, Limit.codec());
+  };
+  Limit.decode = (buf, opts) => {
+    return decodeMessage(buf, Limit.codec(), opts);
+  };
+})(Limit || (Limit = {}));
+var Status;
+(function (Status) {
+  Status["UNUSED"] = "UNUSED";
+  Status["OK"] = "OK";
+  Status["RESERVATION_REFUSED"] = "RESERVATION_REFUSED";
+  Status["RESOURCE_LIMIT_EXCEEDED"] = "RESOURCE_LIMIT_EXCEEDED";
+  Status["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+  Status["CONNECTION_FAILED"] = "CONNECTION_FAILED";
+  Status["NO_RESERVATION"] = "NO_RESERVATION";
+  Status["MALFORMED_MESSAGE"] = "MALFORMED_MESSAGE";
+  Status["UNEXPECTED_MESSAGE"] = "UNEXPECTED_MESSAGE";
+})(Status || (Status = {}));
+var __StatusValues;
+(function (__StatusValues) {
+  __StatusValues[__StatusValues["UNUSED"] = 0] = "UNUSED";
+  __StatusValues[__StatusValues["OK"] = 100] = "OK";
+  __StatusValues[__StatusValues["RESERVATION_REFUSED"] = 200] = "RESERVATION_REFUSED";
+  __StatusValues[__StatusValues["RESOURCE_LIMIT_EXCEEDED"] = 201] = "RESOURCE_LIMIT_EXCEEDED";
+  __StatusValues[__StatusValues["PERMISSION_DENIED"] = 202] = "PERMISSION_DENIED";
+  __StatusValues[__StatusValues["CONNECTION_FAILED"] = 203] = "CONNECTION_FAILED";
+  __StatusValues[__StatusValues["NO_RESERVATION"] = 204] = "NO_RESERVATION";
+  __StatusValues[__StatusValues["MALFORMED_MESSAGE"] = 400] = "MALFORMED_MESSAGE";
+  __StatusValues[__StatusValues["UNEXPECTED_MESSAGE"] = 401] = "UNEXPECTED_MESSAGE";
+})(__StatusValues || (__StatusValues = {}));
+(function (Status) {
+  Status.codec = () => {
+    return enumeration(__StatusValues);
+  };
+})(Status || (Status = {}));
+var ReservationVoucher;
+(function (ReservationVoucher) {
+  let _codec;
+  ReservationVoucher.codec = () => {
+    if (_codec == null) {
+      _codec = message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.relay != null && obj.relay.byteLength > 0) {
+          w.uint32(10);
+          w.bytes(obj.relay);
+        }
+        if (obj.peer != null && obj.peer.byteLength > 0) {
+          w.uint32(18);
+          w.bytes(obj.peer);
+        }
+        if (obj.expiration != null && obj.expiration !== 0n) {
+          w.uint32(24);
+          w.uint64(obj.expiration);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        const obj = {
+          relay: alloc(0),
+          peer: alloc(0),
+          expiration: 0n
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.relay = reader.bytes();
+                break;
+              }
+            case 2:
+              {
+                obj.peer = reader.bytes();
+                break;
+              }
+            case 3:
+              {
+                obj.expiration = reader.uint64();
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  ReservationVoucher.encode = obj => {
+    return encodeMessage(obj, ReservationVoucher.codec());
+  };
+  ReservationVoucher.decode = (buf, opts) => {
+    return decodeMessage(buf, ReservationVoucher.codec(), opts);
+  };
+})(ReservationVoucher || (ReservationVoucher = {}));
+var Envelope;
+(function (Envelope) {
+  let _codec;
+  Envelope.codec = () => {
+    if (_codec == null) {
+      _codec = message(function (obj, w) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (opts.lengthDelimited !== false) {
+          w.fork();
+        }
+        if (obj.publicKey != null && obj.publicKey.byteLength > 0) {
+          w.uint32(10);
+          w.bytes(obj.publicKey);
+        }
+        if (obj.payloadType != null && obj.payloadType.byteLength > 0) {
+          w.uint32(18);
+          w.bytes(obj.payloadType);
+        }
+        if (obj.payload != null) {
+          w.uint32(26);
+          ReservationVoucher.codec().encode(obj.payload, w);
+        }
+        if (obj.signature != null && obj.signature.byteLength > 0) {
+          w.uint32(42);
+          w.bytes(obj.signature);
+        }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim();
+        }
+      }, function (reader, length) {
+        let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        const obj = {
+          publicKey: alloc(0),
+          payloadType: alloc(0),
+          signature: alloc(0)
+        };
+        const end = length == null ? reader.len : reader.pos + length;
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1:
+              {
+                obj.publicKey = reader.bytes();
+                break;
+              }
+            case 2:
+              {
+                obj.payloadType = reader.bytes();
+                break;
+              }
+            case 3:
+              {
+                obj.payload = ReservationVoucher.codec().decode(reader, reader.uint32(), {
+                  limits: opts.limits?.payload
+                });
+                break;
+              }
+            case 5:
+              {
+                obj.signature = reader.bytes();
+                break;
+              }
+            default:
+              {
+                reader.skipType(tag & 7);
+                break;
+              }
+          }
+        }
+        return obj;
+      });
+    }
+    return _codec;
+  };
+  Envelope.encode = obj => {
+    return encodeMessage(obj, Envelope.codec());
+  };
+  Envelope.decode = (buf, opts) => {
+    return decodeMessage(buf, Envelope.codec(), opts);
+  };
+})(Envelope || (Envelope = {}));
+
+export { Envelope, HopMessage, Limit, Peer, Reservation, ReservationVoucher, Status, StopMessage };