@dcl/protocol 1.0.0-3373991894.commit-8aa3a49 → 1.0.0-33874985952.commit-4f4e0ab

package/out-ts/decentraland/kernel/comms/rfc5/ws_comms.gen.ts

@@ -60,9 +60,11 @@ export interface WsIdentification {
 /**
  * This message is received by the peers when the same address logs in in a
  * different session. It should signal that the client should be shut down and not
- * retry any new comms connection.
+ * retry any new comms connection. It can also be used to reject new users joining when
+ * the room capacity has been reached.
  */
 export interface WsKicked {
+  reason: string;
 }
 
 export interface WsPacket {
@@ -74,15 +76,16 @@ export interface WsPacket {
     | { $case: "signedChallengeForServer"; signedChallengeForServer: WsSignedChallenge }
     | { $case: "peerLeaveMessage"; peerLeaveMessage: WsPeerLeave }
     | { $case: "peerIdentification"; peerIdentification: WsIdentification }
-    | { $case: "peerKicked"; peerKicked: WsKicked };
+    | { $case: "peerKicked"; peerKicked: WsKicked }
+    | undefined;
 }
 
 function createBaseWsWelcome(): WsWelcome {
   return { alias: 0, peerIdentities: {} };
 }
 
-export const WsWelcome = {
-  encode(message: WsWelcome, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace WsWelcome {
+  export function encode(message: WsWelcome, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.alias !== 0) {
       writer.uint32(8).uint32(message.alias);
     }
@@ -90,33 +93,42 @@ export const WsWelcome = {
       WsWelcome_PeerIdentitiesEntry.encode({ key: key as any, value }, writer.uint32(18).fork()).ldelim();
     });
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): WsWelcome {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsWelcome {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseWsWelcome();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 8) {
+            break;
+          }
+
           message.alias = reader.uint32();
-          break;
+          continue;
         case 2:
+          if (tag !== 18) {
+            break;
+          }
+
           const entry2 = WsWelcome_PeerIdentitiesEntry.decode(reader, reader.uint32());
           if (entry2.value !== undefined) {
             message.peerIdentities[entry2.key] = entry2.value;
           }
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): WsWelcome {
+  export function fromJSON(object: any): WsWelcome {
     return {
       alias: isSet(object.alias) ? Number(object.alias) : 0,
       peerIdentities: isObject(object.peerIdentities)
@@ -126,9 +138,9 @@ export const WsWelcome = {
         }, {})
         : {},
     };
-  },
+  }
 
-  toJSON(message: WsWelcome): unknown {
+  export function toJSON(message: WsWelcome): unknown {
     const obj: any = {};
     message.alias !== undefined && (obj.alias = Math.round(message.alias));
     obj.peerIdentities = {};
@@ -138,9 +150,13 @@ export const WsWelcome = {
       });
     }
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<WsWelcome>, I>>(object: I): WsWelcome {
+  export function create<I extends Exact<DeepPartial<WsWelcome>, I>>(base?: I): WsWelcome {
+    return WsWelcome.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsWelcome>, I>>(object: I): WsWelcome {
     const message = createBaseWsWelcome();
     message.alias = object.alias ?? 0;
     message.peerIdentities = Object.entries(object.peerIdentities ?? {}).reduce<{ [key: number]: string }>(
@@ -153,15 +169,15 @@ export const WsWelcome = {
       {},
     );
     return message;
-  },
-};
+  }
+}
 
 function createBaseWsWelcome_PeerIdentitiesEntry(): WsWelcome_PeerIdentitiesEntry {
   return { key: 0, value: "" };
 }
 
-export const WsWelcome_PeerIdentitiesEntry = {
-  encode(message: WsWelcome_PeerIdentitiesEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace WsWelcome_PeerIdentitiesEntry {
+  export function encode(message: WsWelcome_PeerIdentitiesEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.key !== 0) {
       writer.uint32(8).uint32(message.key);
     }
@@ -169,56 +185,71 @@ export const WsWelcome_PeerIdentitiesEntry = {
       writer.uint32(18).string(message.value);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): WsWelcome_PeerIdentitiesEntry {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsWelcome_PeerIdentitiesEntry {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseWsWelcome_PeerIdentitiesEntry();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 8) {
+            break;
+          }
+
           message.key = reader.uint32();
-          break;
+          continue;
         case 2:
+          if (tag !== 18) {
+            break;
+          }
+
           message.value = reader.string();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): WsWelcome_PeerIdentitiesEntry {
+  export function fromJSON(object: any): WsWelcome_PeerIdentitiesEntry {
     return { key: isSet(object.key) ? Number(object.key) : 0, value: isSet(object.value) ? String(object.value) : "" };
-  },
+  }
 
-  toJSON(message: WsWelcome_PeerIdentitiesEntry): unknown {
+  export function toJSON(message: WsWelcome_PeerIdentitiesEntry): unknown {
     const obj: any = {};
     message.key !== undefined && (obj.key = Math.round(message.key));
     message.value !== undefined && (obj.value = message.value);
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<WsWelcome_PeerIdentitiesEntry>, I>>(
+    base?: I,
+  ): WsWelcome_PeerIdentitiesEntry {
+    return WsWelcome_PeerIdentitiesEntry.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<WsWelcome_PeerIdentitiesEntry>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<WsWelcome_PeerIdentitiesEntry>, I>>(
     object: I,
   ): WsWelcome_PeerIdentitiesEntry {
     const message = createBaseWsWelcome_PeerIdentitiesEntry();
     message.key = object.key ?? 0;
     message.value = object.value ?? "";
     return message;
-  },
-};
+  }
+}
 
 function createBaseWsPeerJoin(): WsPeerJoin {
   return { alias: 0, address: "" };
 }
 
-export const WsPeerJoin = {
-  encode(message: WsPeerJoin, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace WsPeerJoin {
+  export function encode(message: WsPeerJoin, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.alias !== 0) {
       writer.uint32(8).uint32(message.alias);
     }
@@ -226,104 +257,126 @@ export const WsPeerJoin = {
       writer.uint32(18).string(message.address);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): WsPeerJoin {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsPeerJoin {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseWsPeerJoin();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 8) {
+            break;
+          }
+
           message.alias = reader.uint32();
-          break;
+          continue;
         case 2:
+          if (tag !== 18) {
+            break;
+          }
+
           message.address = reader.string();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): WsPeerJoin {
+  export function fromJSON(object: any): WsPeerJoin {
     return {
       alias: isSet(object.alias) ? Number(object.alias) : 0,
       address: isSet(object.address) ? String(object.address) : "",
     };
-  },
+  }
 
-  toJSON(message: WsPeerJoin): unknown {
+  export function toJSON(message: WsPeerJoin): unknown {
     const obj: any = {};
     message.alias !== undefined && (obj.alias = Math.round(message.alias));
     message.address !== undefined && (obj.address = message.address);
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<WsPeerJoin>, I>>(base?: I): WsPeerJoin {
+    return WsPeerJoin.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<WsPeerJoin>, I>>(object: I): WsPeerJoin {
+  export function fromPartial<I extends Exact<DeepPartial<WsPeerJoin>, I>>(object: I): WsPeerJoin {
     const message = createBaseWsPeerJoin();
     message.alias = object.alias ?? 0;
     message.address = object.address ?? "";
     return message;
-  },
-};
+  }
+}
 
 function createBaseWsPeerLeave(): WsPeerLeave {
   return { alias: 0 };
 }
 
-export const WsPeerLeave = {
-  encode(message: WsPeerLeave, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace WsPeerLeave {
+  export function encode(message: WsPeerLeave, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.alias !== 0) {
       writer.uint32(8).uint32(message.alias);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): WsPeerLeave {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsPeerLeave {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseWsPeerLeave();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 8) {
+            break;
+          }
+
           message.alias = reader.uint32();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): WsPeerLeave {
+  export function fromJSON(object: any): WsPeerLeave {
     return { alias: isSet(object.alias) ? Number(object.alias) : 0 };
-  },
+  }
 
-  toJSON(message: WsPeerLeave): unknown {
+  export function toJSON(message: WsPeerLeave): unknown {
     const obj: any = {};
     message.alias !== undefined && (obj.alias = Math.round(message.alias));
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<WsPeerLeave>, I>>(object: I): WsPeerLeave {
+  export function create<I extends Exact<DeepPartial<WsPeerLeave>, I>>(base?: I): WsPeerLeave {
+    return WsPeerLeave.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsPeerLeave>, I>>(object: I): WsPeerLeave {
     const message = createBaseWsPeerLeave();
     message.alias = object.alias ?? 0;
     return message;
-  },
-};
+  }
+}
 
 function createBaseWsPeerUpdate(): WsPeerUpdate {
-  return { fromAlias: 0, body: new Uint8Array(), unreliable: false };
+  return { fromAlias: 0, body: new Uint8Array(0), unreliable: false };
 }
 
-export const WsPeerUpdate = {
-  encode(message: WsPeerUpdate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace WsPeerUpdate {
+  export function encode(message: WsPeerUpdate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.fromAlias !== 0) {
       writer.uint32(8).uint32(message.fromAlias);
     }
@@ -334,64 +387,81 @@ export const WsPeerUpdate = {
       writer.uint32(24).bool(message.unreliable);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): WsPeerUpdate {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsPeerUpdate {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseWsPeerUpdate();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 8) {
+            break;
+          }
+
           message.fromAlias = reader.uint32();
-          break;
+          continue;
         case 2:
+          if (tag !== 18) {
+            break;
+          }
+
           message.body = reader.bytes();
-          break;
+          continue;
         case 3:
+          if (tag !== 24) {
+            break;
+          }
+
           message.unreliable = reader.bool();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): WsPeerUpdate {
+  export function fromJSON(object: any): WsPeerUpdate {
     return {
       fromAlias: isSet(object.fromAlias) ? Number(object.fromAlias) : 0,
-      body: isSet(object.body) ? bytesFromBase64(object.body) : new Uint8Array(),
+      body: isSet(object.body) ? bytesFromBase64(object.body) : new Uint8Array(0),
       unreliable: isSet(object.unreliable) ? Boolean(object.unreliable) : false,
     };
-  },
+  }
 
-  toJSON(message: WsPeerUpdate): unknown {
+  export function toJSON(message: WsPeerUpdate): unknown {
     const obj: any = {};
     message.fromAlias !== undefined && (obj.fromAlias = Math.round(message.fromAlias));
     message.body !== undefined &&
-      (obj.body = base64FromBytes(message.body !== undefined ? message.body : new Uint8Array()));
+      (obj.body = base64FromBytes(message.body !== undefined ? message.body : new Uint8Array(0)));
     message.unreliable !== undefined && (obj.unreliable = message.unreliable);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<WsPeerUpdate>, I>>(object: I): WsPeerUpdate {
+  export function create<I extends Exact<DeepPartial<WsPeerUpdate>, I>>(base?: I): WsPeerUpdate {
+    return WsPeerUpdate.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsPeerUpdate>, I>>(object: I): WsPeerUpdate {
     const message = createBaseWsPeerUpdate();
     message.fromAlias = object.fromAlias ?? 0;
-    message.body = object.body ?? new Uint8Array();
+    message.body = object.body ?? new Uint8Array(0);
     message.unreliable = object.unreliable ?? false;
     return message;
-  },
-};
+  }
+}
 
 function createBaseWsChallengeRequired(): WsChallengeRequired {
   return { challengeToSign: "", alreadyConnected: false };
 }
 
-export const WsChallengeRequired = {
-  encode(message: WsChallengeRequired, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace WsChallengeRequired {
+  export function encode(message: WsChallengeRequired, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.challengeToSign !== "") {
       writer.uint32(10).string(message.challengeToSign);
     }
@@ -399,272 +469,355 @@ export const WsChallengeRequired = {
       writer.uint32(16).bool(message.alreadyConnected);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): WsChallengeRequired {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsChallengeRequired {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseWsChallengeRequired();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 10) {
+            break;
+          }
+
           message.challengeToSign = reader.string();
-          break;
+          continue;
         case 2:
+          if (tag !== 16) {
+            break;
+          }
+
           message.alreadyConnected = reader.bool();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): WsChallengeRequired {
+  export function fromJSON(object: any): WsChallengeRequired {
     return {
       challengeToSign: isSet(object.challengeToSign) ? String(object.challengeToSign) : "",
       alreadyConnected: isSet(object.alreadyConnected) ? Boolean(object.alreadyConnected) : false,
     };
-  },
+  }
 
-  toJSON(message: WsChallengeRequired): unknown {
+  export function toJSON(message: WsChallengeRequired): unknown {
     const obj: any = {};
     message.challengeToSign !== undefined && (obj.challengeToSign = message.challengeToSign);
     message.alreadyConnected !== undefined && (obj.alreadyConnected = message.alreadyConnected);
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<WsChallengeRequired>, I>>(base?: I): WsChallengeRequired {
+    return WsChallengeRequired.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<WsChallengeRequired>, I>>(object: I): WsChallengeRequired {
+  export function fromPartial<I extends Exact<DeepPartial<WsChallengeRequired>, I>>(object: I): WsChallengeRequired {
     const message = createBaseWsChallengeRequired();
     message.challengeToSign = object.challengeToSign ?? "";
     message.alreadyConnected = object.alreadyConnected ?? false;
     return message;
-  },
-};
+  }
+}
 
 function createBaseWsSignedChallenge(): WsSignedChallenge {
   return { authChainJson: "" };
 }
 
-export const WsSignedChallenge = {
-  encode(message: WsSignedChallenge, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace WsSignedChallenge {
+  export function encode(message: WsSignedChallenge, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.authChainJson !== "") {
       writer.uint32(10).string(message.authChainJson);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): WsSignedChallenge {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsSignedChallenge {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseWsSignedChallenge();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 10) {
+            break;
+          }
+
           message.authChainJson = reader.string();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): WsSignedChallenge {
+  export function fromJSON(object: any): WsSignedChallenge {
     return { authChainJson: isSet(object.authChainJson) ? String(object.authChainJson) : "" };
-  },
+  }
 
-  toJSON(message: WsSignedChallenge): unknown {
+  export function toJSON(message: WsSignedChallenge): unknown {
     const obj: any = {};
     message.authChainJson !== undefined && (obj.authChainJson = message.authChainJson);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<WsSignedChallenge>, I>>(object: I): WsSignedChallenge {
+  export function create<I extends Exact<DeepPartial<WsSignedChallenge>, I>>(base?: I): WsSignedChallenge {
+    return WsSignedChallenge.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsSignedChallenge>, I>>(object: I): WsSignedChallenge {
     const message = createBaseWsSignedChallenge();
     message.authChainJson = object.authChainJson ?? "";
     return message;
-  },
-};
+  }
+}
 
 function createBaseWsIdentification(): WsIdentification {
   return { address: "" };
 }
 
-export const WsIdentification = {
-  encode(message: WsIdentification, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace WsIdentification {
+  export function encode(message: WsIdentification, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.address !== "") {
       writer.uint32(10).string(message.address);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): WsIdentification {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsIdentification {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseWsIdentification();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 10) {
+            break;
+          }
+
           message.address = reader.string();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): WsIdentification {
+  export function fromJSON(object: any): WsIdentification {
     return { address: isSet(object.address) ? String(object.address) : "" };
-  },
+  }
 
-  toJSON(message: WsIdentification): unknown {
+  export function toJSON(message: WsIdentification): unknown {
     const obj: any = {};
     message.address !== undefined && (obj.address = message.address);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<WsIdentification>, I>>(object: I): WsIdentification {
+  export function create<I extends Exact<DeepPartial<WsIdentification>, I>>(base?: I): WsIdentification {
+    return WsIdentification.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsIdentification>, I>>(object: I): WsIdentification {
     const message = createBaseWsIdentification();
     message.address = object.address ?? "";
     return message;
-  },
-};
+  }
+}
 
 function createBaseWsKicked(): WsKicked {
-  return {};
+  return { reason: "" };
 }
 
-export const WsKicked = {
-  encode(_: WsKicked, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace WsKicked {
+  export function encode(message: WsKicked, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.reason !== "") {
+      writer.uint32(10).string(message.reason);
+    }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): WsKicked {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsKicked {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseWsKicked();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        default:
-          reader.skipType(tag & 7);
-          break;
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.reason = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(_: any): WsKicked {
-    return {};
-  },
+  export function fromJSON(object: any): WsKicked {
+    return { reason: isSet(object.reason) ? String(object.reason) : "" };
+  }
 
-  toJSON(_: WsKicked): unknown {
+  export function toJSON(message: WsKicked): unknown {
     const obj: any = {};
+    message.reason !== undefined && (obj.reason = message.reason);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<WsKicked>, I>>(_: I): WsKicked {
+  export function create<I extends Exact<DeepPartial<WsKicked>, I>>(base?: I): WsKicked {
+    return WsKicked.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsKicked>, I>>(object: I): WsKicked {
     const message = createBaseWsKicked();
+    message.reason = object.reason ?? "";
     return message;
-  },
-};
+  }
+}
 
 function createBaseWsPacket(): WsPacket {
   return { message: undefined };
 }
 
-export const WsPacket = {
-  encode(message: WsPacket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.message?.$case === "welcomeMessage") {
-      WsWelcome.encode(message.message.welcomeMessage, writer.uint32(10).fork()).ldelim();
-    }
-    if (message.message?.$case === "peerJoinMessage") {
-      WsPeerJoin.encode(message.message.peerJoinMessage, writer.uint32(18).fork()).ldelim();
-    }
-    if (message.message?.$case === "peerUpdateMessage") {
-      WsPeerUpdate.encode(message.message.peerUpdateMessage, writer.uint32(26).fork()).ldelim();
-    }
-    if (message.message?.$case === "challengeMessage") {
-      WsChallengeRequired.encode(message.message.challengeMessage, writer.uint32(34).fork()).ldelim();
-    }
-    if (message.message?.$case === "signedChallengeForServer") {
-      WsSignedChallenge.encode(message.message.signedChallengeForServer, writer.uint32(42).fork()).ldelim();
-    }
-    if (message.message?.$case === "peerLeaveMessage") {
-      WsPeerLeave.encode(message.message.peerLeaveMessage, writer.uint32(50).fork()).ldelim();
-    }
-    if (message.message?.$case === "peerIdentification") {
-      WsIdentification.encode(message.message.peerIdentification, writer.uint32(58).fork()).ldelim();
-    }
-    if (message.message?.$case === "peerKicked") {
-      WsKicked.encode(message.message.peerKicked, writer.uint32(66).fork()).ldelim();
+export namespace WsPacket {
+  export function encode(message: WsPacket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.message?.$case) {
+      case "welcomeMessage":
+        WsWelcome.encode(message.message.welcomeMessage, writer.uint32(10).fork()).ldelim();
+        break;
+      case "peerJoinMessage":
+        WsPeerJoin.encode(message.message.peerJoinMessage, writer.uint32(18).fork()).ldelim();
+        break;
+      case "peerUpdateMessage":
+        WsPeerUpdate.encode(message.message.peerUpdateMessage, writer.uint32(26).fork()).ldelim();
+        break;
+      case "challengeMessage":
+        WsChallengeRequired.encode(message.message.challengeMessage, writer.uint32(34).fork()).ldelim();
+        break;
+      case "signedChallengeForServer":
+        WsSignedChallenge.encode(message.message.signedChallengeForServer, writer.uint32(42).fork()).ldelim();
+        break;
+      case "peerLeaveMessage":
+        WsPeerLeave.encode(message.message.peerLeaveMessage, writer.uint32(50).fork()).ldelim();
+        break;
+      case "peerIdentification":
+        WsIdentification.encode(message.message.peerIdentification, writer.uint32(58).fork()).ldelim();
+        break;
+      case "peerKicked":
+        WsKicked.encode(message.message.peerKicked, writer.uint32(66).fork()).ldelim();
+        break;
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): WsPacket {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsPacket {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseWsPacket();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 10) {
+            break;
+          }
+
           message.message = { $case: "welcomeMessage", welcomeMessage: WsWelcome.decode(reader, reader.uint32()) };
-          break;
+          continue;
         case 2:
+          if (tag !== 18) {
+            break;
+          }
+
           message.message = { $case: "peerJoinMessage", peerJoinMessage: WsPeerJoin.decode(reader, reader.uint32()) };
-          break;
+          continue;
         case 3:
+          if (tag !== 26) {
+            break;
+          }
+
           message.message = {
             $case: "peerUpdateMessage",
             peerUpdateMessage: WsPeerUpdate.decode(reader, reader.uint32()),
           };
-          break;
+          continue;
         case 4:
+          if (tag !== 34) {
+            break;
+          }
+
           message.message = {
             $case: "challengeMessage",
             challengeMessage: WsChallengeRequired.decode(reader, reader.uint32()),
           };
-          break;
+          continue;
         case 5:
+          if (tag !== 42) {
+            break;
+          }
+
           message.message = {
             $case: "signedChallengeForServer",
             signedChallengeForServer: WsSignedChallenge.decode(reader, reader.uint32()),
           };
-          break;
+          continue;
         case 6:
+          if (tag !== 50) {
+            break;
+          }
+
           message.message = {
             $case: "peerLeaveMessage",
             peerLeaveMessage: WsPeerLeave.decode(reader, reader.uint32()),
           };
-          break;
+          continue;
         case 7:
+          if (tag !== 58) {
+            break;
+          }
+
           message.message = {
             $case: "peerIdentification",
             peerIdentification: WsIdentification.decode(reader, reader.uint32()),
           };
-          break;
+          continue;
         case 8:
+          if (tag !== 66) {
+            break;
+          }
+
           message.message = { $case: "peerKicked", peerKicked: WsKicked.decode(reader, reader.uint32()) };
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): WsPacket {
+  export function fromJSON(object: any): WsPacket {
     return {
       message: isSet(object.welcomeMessage)
         ? { $case: "welcomeMessage", welcomeMessage: WsWelcome.fromJSON(object.welcomeMessage) }
@@ -687,38 +840,48 @@ export const WsPacket = {
         ? { $case: "peerKicked", peerKicked: WsKicked.fromJSON(object.peerKicked) }
         : undefined,
     };
-  },
+  }
 
-  toJSON(message: WsPacket): unknown {
+  export function toJSON(message: WsPacket): unknown {
     const obj: any = {};
-    message.message?.$case === "welcomeMessage" && (obj.welcomeMessage = message.message?.welcomeMessage
-      ? WsWelcome.toJSON(message.message?.welcomeMessage)
-      : undefined);
-    message.message?.$case === "peerJoinMessage" && (obj.peerJoinMessage = message.message?.peerJoinMessage
-      ? WsPeerJoin.toJSON(message.message?.peerJoinMessage)
-      : undefined);
-    message.message?.$case === "peerUpdateMessage" && (obj.peerUpdateMessage = message.message?.peerUpdateMessage
-      ? WsPeerUpdate.toJSON(message.message?.peerUpdateMessage)
-      : undefined);
-    message.message?.$case === "challengeMessage" && (obj.challengeMessage = message.message?.challengeMessage
-      ? WsChallengeRequired.toJSON(message.message?.challengeMessage)
-      : undefined);
+    message.message?.$case === "welcomeMessage" &&
+      (obj.welcomeMessage = message.message?.welcomeMessage
+        ? WsWelcome.toJSON(message.message?.welcomeMessage)
+        : undefined);
+    message.message?.$case === "peerJoinMessage" &&
+      (obj.peerJoinMessage = message.message?.peerJoinMessage
+        ? WsPeerJoin.toJSON(message.message?.peerJoinMessage)
+        : undefined);
+    message.message?.$case === "peerUpdateMessage" &&
+      (obj.peerUpdateMessage = message.message?.peerUpdateMessage
+        ? WsPeerUpdate.toJSON(message.message?.peerUpdateMessage)
+        : undefined);
+    message.message?.$case === "challengeMessage" &&
+      (obj.challengeMessage = message.message?.challengeMessage
+        ? WsChallengeRequired.toJSON(message.message?.challengeMessage)
+        : undefined);
     message.message?.$case === "signedChallengeForServer" &&
       (obj.signedChallengeForServer = message.message?.signedChallengeForServer
         ? WsSignedChallenge.toJSON(message.message?.signedChallengeForServer)
         : undefined);
-    message.message?.$case === "peerLeaveMessage" && (obj.peerLeaveMessage = message.message?.peerLeaveMessage
-      ? WsPeerLeave.toJSON(message.message?.peerLeaveMessage)
-      : undefined);
-    message.message?.$case === "peerIdentification" && (obj.peerIdentification = message.message?.peerIdentification
-      ? WsIdentification.toJSON(message.message?.peerIdentification)
-      : undefined);
+    message.message?.$case === "peerLeaveMessage" &&
+      (obj.peerLeaveMessage = message.message?.peerLeaveMessage
+        ? WsPeerLeave.toJSON(message.message?.peerLeaveMessage)
+        : undefined);
+    message.message?.$case === "peerIdentification" &&
+      (obj.peerIdentification = message.message?.peerIdentification
+        ? WsIdentification.toJSON(message.message?.peerIdentification)
+        : undefined);
     message.message?.$case === "peerKicked" &&
       (obj.peerKicked = message.message?.peerKicked ? WsKicked.toJSON(message.message?.peerKicked) : undefined);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<WsPacket>, I>>(object: I): WsPacket {
+  export function create<I extends Exact<DeepPartial<WsPacket>, I>>(base?: I): WsPacket {
+    return WsPacket.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsPacket>, I>>(object: I): WsPacket {
     const message = createBaseWsPacket();
     if (
       object.message?.$case === "welcomeMessage" &&
@@ -798,13 +961,13 @@ export const WsPacket = {
       message.message = { $case: "peerKicked", peerKicked: WsKicked.fromPartial(object.message.peerKicked) };
     }
     return message;
-  },
-};
+  }
+}
 
-declare var self: any | undefined;
-declare var window: any | undefined;
-declare var global: any | undefined;
-var globalThis: any = (() => {
+declare const self: any | undefined;
+declare const window: any | undefined;
+declare const global: any | undefined;
+const tsProtoGlobalThis: any = (() => {
   if (typeof globalThis !== "undefined") {
     return globalThis;
   }
@@ -821,10 +984,10 @@ var globalThis: any = (() => {
 })();
 
 function bytesFromBase64(b64: string): Uint8Array {
-  if (globalThis.Buffer) {
-    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  if (tsProtoGlobalThis.Buffer) {
+    return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
   } else {
-    const bin = globalThis.atob(b64);
+    const bin = tsProtoGlobalThis.atob(b64);
     const arr = new Uint8Array(bin.length);
     for (let i = 0; i < bin.length; ++i) {
       arr[i] = bin.charCodeAt(i);
@@ -834,14 +997,14 @@ function bytesFromBase64(b64: string): Uint8Array {
 }
 
 function base64FromBytes(arr: Uint8Array): string {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.from(arr).toString("base64");
+  if (tsProtoGlobalThis.Buffer) {
+    return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
   } else {
     const bin: string[] = [];
     arr.forEach((byte) => {
       bin.push(String.fromCharCode(byte));
     });
-    return globalThis.btoa(bin.join(""));
+    return tsProtoGlobalThis.btoa(bin.join(""));
   }
 }