@dcl/protocol 1.0.0-3482040729.commit-4f0f6b5 → 1.0.0-34848312390.commit-ca008c2

package/out-ts/decentraland/kernel/comms/v3/archipelago.gen.ts

@@ -1,57 +1,57 @@
 /* eslint-disable */
+import Long from "long";
 import _m0 from "protobufjs/minimal";
+import { Position } from "../../../common/vectors.gen";
 
 export const protobufPackage = "decentraland.kernel.comms.v3";
 
-export enum TransportType {
-  TT_LIVEKIT = 0,
-  TT_WS = 1,
+export enum KickedReason {
+  KR_NEW_SESSION = 0,
   UNRECOGNIZED = -1,
 }
 
-export function transportTypeFromJSON(object: any): TransportType {
+export function kickedReasonFromJSON(object: any): KickedReason {
   switch (object) {
     case 0:
-    case "TT_LIVEKIT":
-      return TransportType.TT_LIVEKIT;
-    case 1:
-    case "TT_WS":
-      return TransportType.TT_WS;
+    case "KR_NEW_SESSION":
+      return KickedReason.KR_NEW_SESSION;
     case -1:
     case "UNRECOGNIZED":
     default:
-      return TransportType.UNRECOGNIZED;
+      return KickedReason.UNRECOGNIZED;
   }
 }
 
-export function transportTypeToJSON(object: TransportType): string {
+export function kickedReasonToJSON(object: KickedReason): string {
   switch (object) {
-    case TransportType.TT_LIVEKIT:
-      return "TT_LIVEKIT";
-    case TransportType.TT_WS:
-      return "TT_WS";
-    case TransportType.UNRECOGNIZED:
+    case KickedReason.KR_NEW_SESSION:
+      return "KR_NEW_SESSION";
+    case KickedReason.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
   }
 }
 
-export interface Position3DMessage {
-  x: number;
-  y: number;
-  z: number;
+/** Server->Client messsages */
+export interface ChallengeResponseMessage {
+  challengeToSign: string;
+  alreadyConnected: boolean;
+}
+
+export interface WelcomeMessage {
+  peerId: string;
 }
 
 export interface IslandChangedMessage {
   islandId: string;
   connStr: string;
   fromIslandId?: string | undefined;
-  peers: { [key: string]: Position3DMessage };
+  peers: { [key: string]: Position };
 }
 
 export interface IslandChangedMessage_PeersEntry {
   key: string;
-  value: Position3DMessage | undefined;
+  value: Position | undefined;
 }
 
 export interface LeftIslandMessage {
@@ -64,11 +64,49 @@ export interface JoinIslandMessage {
   peerId: string;
 }
 
+export interface KickedMessage {
+  reason: KickedReason;
+}
+
+export interface ServerPacket {
+  message?:
+    | { $case: "challengeResponse"; challengeResponse: ChallengeResponseMessage }
+    | { $case: "welcome"; welcome: WelcomeMessage }
+    | { $case: "islandChanged"; islandChanged: IslandChangedMessage }
+    | { $case: "leftIsland"; leftIsland: LeftIslandMessage }
+    | { $case: "joinIsland"; joinIsland: JoinIslandMessage }
+    | { $case: "kicked"; kicked: KickedMessage }
+    | undefined;
+}
+
+/** Client->Server messsages */
+export interface ChallengeRequestMessage {
+  address: string;
+}
+
+export interface SignedChallengeMessage {
+  authChainJson: string;
+}
+
+export interface Heartbeat {
+  position: Position | undefined;
+  desiredRoom?: string | undefined;
+}
+
+export interface ClientPacket {
+  message?:
+    | { $case: "challengeRequest"; challengeRequest: ChallengeRequestMessage }
+    | { $case: "signedChallenge"; signedChallenge: SignedChallengeMessage }
+    | { $case: "heartbeat"; heartbeat: Heartbeat }
+    | undefined;
+}
+
+/** Others */
 export interface IslandData {
   id: string;
   peers: string[];
   maxPeers: number;
-  center: Position3DMessage | undefined;
+  center: Position | undefined;
   radius: number;
 }
 
@@ -76,112 +114,154 @@ export interface IslandStatusMessage {
   data: IslandData[];
 }
 
-export interface TransportInit {
-  type: TransportType;
-  maxIslandSize: number;
+export interface ServiceStatus {
+  currentTime: number;
+  commitHash?: string | undefined;
+  userCount: number;
 }
 
-export interface TransportHeartbeat {
-  availableSeats: number;
-  usersCount: number;
+export interface ServiceDiscoveryMessage {
+  serverName: string;
+  status: ServiceStatus | undefined;
 }
 
-export interface TransportAuthorizationRequest {
-  requestId: string;
-  roomId: string;
-  userIds: string[];
+function createBaseChallengeResponseMessage(): ChallengeResponseMessage {
+  return { challengeToSign: "", alreadyConnected: false };
 }
 
-export interface TransportAuthorizationResponse {
-  requestId: string;
-  connStrs: { [key: string]: string };
-}
+export namespace ChallengeResponseMessage {
+  export function encode(message: ChallengeResponseMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.challengeToSign !== "") {
+      writer.uint32(10).string(message.challengeToSign);
+    }
+    if (message.alreadyConnected === true) {
+      writer.uint32(16).bool(message.alreadyConnected);
+    }
+    return writer;
+  }
 
-export interface TransportAuthorizationResponse_ConnStrsEntry {
-  key: string;
-  value: string;
-}
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ChallengeResponseMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseChallengeResponseMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.challengeToSign = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.alreadyConnected = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ChallengeResponseMessage {
+    return {
+      challengeToSign: isSet(object.challengeToSign) ? String(object.challengeToSign) : "",
+      alreadyConnected: isSet(object.alreadyConnected) ? Boolean(object.alreadyConnected) : false,
+    };
+  }
+
+  export function toJSON(message: ChallengeResponseMessage): 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<ChallengeResponseMessage>, I>>(
+    base?: I,
+  ): ChallengeResponseMessage {
+    return ChallengeResponseMessage.fromPartial(base ?? {});
+  }
 
-export interface TransportMessage {
-  message?: { $case: "init"; init: TransportInit } | { $case: "heartbeat"; heartbeat: TransportHeartbeat } | {
-    $case: "authRequest";
-    authRequest: TransportAuthorizationRequest;
-  } | { $case: "authResponse"; authResponse: TransportAuthorizationResponse };
+  export function fromPartial<I extends Exact<DeepPartial<ChallengeResponseMessage>, I>>(
+    object: I,
+  ): ChallengeResponseMessage {
+    const message = createBaseChallengeResponseMessage();
+    message.challengeToSign = object.challengeToSign ?? "";
+    message.alreadyConnected = object.alreadyConnected ?? false;
+    return message;
+  }
 }
 
-function createBasePosition3DMessage(): Position3DMessage {
-  return { x: 0, y: 0, z: 0 };
+function createBaseWelcomeMessage(): WelcomeMessage {
+  return { peerId: "" };
 }
 
-export const Position3DMessage = {
-  encode(message: Position3DMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.x !== 0) {
-      writer.uint32(9).double(message.x);
-    }
-    if (message.y !== 0) {
-      writer.uint32(17).double(message.y);
-    }
-    if (message.z !== 0) {
-      writer.uint32(25).double(message.z);
+export namespace WelcomeMessage {
+  export function encode(message: WelcomeMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.peerId !== "") {
+      writer.uint32(10).string(message.peerId);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Position3DMessage {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WelcomeMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBasePosition3DMessage();
+    const message = createBaseWelcomeMessage();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.x = reader.double();
-          break;
-        case 2:
-          message.y = reader.double();
-          break;
-        case 3:
-          message.z = reader.double();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          if (tag !== 10) {
+            break;
+          }
+
+          message.peerId = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): Position3DMessage {
-    return {
-      x: isSet(object.x) ? Number(object.x) : 0,
-      y: isSet(object.y) ? Number(object.y) : 0,
-      z: isSet(object.z) ? Number(object.z) : 0,
-    };
-  },
+  export function fromJSON(object: any): WelcomeMessage {
+    return { peerId: isSet(object.peerId) ? String(object.peerId) : "" };
+  }
 
-  toJSON(message: Position3DMessage): unknown {
+  export function toJSON(message: WelcomeMessage): unknown {
     const obj: any = {};
-    message.x !== undefined && (obj.x = message.x);
-    message.y !== undefined && (obj.y = message.y);
-    message.z !== undefined && (obj.z = message.z);
+    message.peerId !== undefined && (obj.peerId = message.peerId);
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<WelcomeMessage>, I>>(base?: I): WelcomeMessage {
+    return WelcomeMessage.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<Position3DMessage>, I>>(object: I): Position3DMessage {
-    const message = createBasePosition3DMessage();
-    message.x = object.x ?? 0;
-    message.y = object.y ?? 0;
-    message.z = object.z ?? 0;
+  export function fromPartial<I extends Exact<DeepPartial<WelcomeMessage>, I>>(object: I): WelcomeMessage {
+    const message = createBaseWelcomeMessage();
+    message.peerId = object.peerId ?? "";
     return message;
-  },
-};
+  }
+}
 
 function createBaseIslandChangedMessage(): IslandChangedMessage {
   return { islandId: "", connStr: "", fromIslandId: undefined, peers: {} };
 }
 
-export const IslandChangedMessage = {
-  encode(message: IslandChangedMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace IslandChangedMessage {
+  export function encode(message: IslandChangedMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.islandId !== "") {
       writer.uint32(10).string(message.islandId);
     }
@@ -195,53 +275,70 @@ export const IslandChangedMessage = {
       IslandChangedMessage_PeersEntry.encode({ key: key as any, value }, writer.uint32(34).fork()).ldelim();
     });
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): IslandChangedMessage {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): IslandChangedMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseIslandChangedMessage();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 10) {
+            break;
+          }
+
           message.islandId = reader.string();
-          break;
+          continue;
         case 2:
+          if (tag !== 18) {
+            break;
+          }
+
           message.connStr = reader.string();
-          break;
+          continue;
         case 3:
+          if (tag !== 26) {
+            break;
+          }
+
           message.fromIslandId = reader.string();
-          break;
+          continue;
         case 4:
+          if (tag !== 34) {
+            break;
+          }
+
           const entry4 = IslandChangedMessage_PeersEntry.decode(reader, reader.uint32());
           if (entry4.value !== undefined) {
             message.peers[entry4.key] = entry4.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): IslandChangedMessage {
+  export function fromJSON(object: any): IslandChangedMessage {
     return {
       islandId: isSet(object.islandId) ? String(object.islandId) : "",
       connStr: isSet(object.connStr) ? String(object.connStr) : "",
       fromIslandId: isSet(object.fromIslandId) ? String(object.fromIslandId) : undefined,
       peers: isObject(object.peers)
-        ? Object.entries(object.peers).reduce<{ [key: string]: Position3DMessage }>((acc, [key, value]) => {
-          acc[key] = Position3DMessage.fromJSON(value);
+        ? Object.entries(object.peers).reduce<{ [key: string]: Position }>((acc, [key, value]) => {
+          acc[key] = Position.fromJSON(value);
           return acc;
         }, {})
         : {},
     };
-  },
+  }
 
-  toJSON(message: IslandChangedMessage): unknown {
+  export function toJSON(message: IslandChangedMessage): unknown {
     const obj: any = {};
     message.islandId !== undefined && (obj.islandId = message.islandId);
     message.connStr !== undefined && (obj.connStr = message.connStr);
@@ -249,98 +346,117 @@ export const IslandChangedMessage = {
     obj.peers = {};
     if (message.peers) {
       Object.entries(message.peers).forEach(([k, v]) => {
-        obj.peers[k] = Position3DMessage.toJSON(v);
+        obj.peers[k] = Position.toJSON(v);
       });
     }
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<IslandChangedMessage>, I>>(object: I): IslandChangedMessage {
+  export function create<I extends Exact<DeepPartial<IslandChangedMessage>, I>>(base?: I): IslandChangedMessage {
+    return IslandChangedMessage.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<IslandChangedMessage>, I>>(object: I): IslandChangedMessage {
     const message = createBaseIslandChangedMessage();
     message.islandId = object.islandId ?? "";
     message.connStr = object.connStr ?? "";
     message.fromIslandId = object.fromIslandId ?? undefined;
-    message.peers = Object.entries(object.peers ?? {}).reduce<{ [key: string]: Position3DMessage }>(
-      (acc, [key, value]) => {
-        if (value !== undefined) {
-          acc[key] = Position3DMessage.fromPartial(value);
-        }
-        return acc;
-      },
-      {},
-    );
+    message.peers = Object.entries(object.peers ?? {}).reduce<{ [key: string]: Position }>((acc, [key, value]) => {
+      if (value !== undefined) {
+        acc[key] = Position.fromPartial(value);
+      }
+      return acc;
+    }, {});
     return message;
-  },
-};
+  }
+}
 
 function createBaseIslandChangedMessage_PeersEntry(): IslandChangedMessage_PeersEntry {
   return { key: "", value: undefined };
 }
 
-export const IslandChangedMessage_PeersEntry = {
-  encode(message: IslandChangedMessage_PeersEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace IslandChangedMessage_PeersEntry {
+  export function encode(
+    message: IslandChangedMessage_PeersEntry,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
     if (message.key !== "") {
       writer.uint32(10).string(message.key);
     }
     if (message.value !== undefined) {
-      Position3DMessage.encode(message.value, writer.uint32(18).fork()).ldelim();
+      Position.encode(message.value, writer.uint32(18).fork()).ldelim();
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): IslandChangedMessage_PeersEntry {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): IslandChangedMessage_PeersEntry {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseIslandChangedMessage_PeersEntry();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 10) {
+            break;
+          }
+
           message.key = reader.string();
-          break;
+          continue;
         case 2:
-          message.value = Position3DMessage.decode(reader, reader.uint32());
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = Position.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): IslandChangedMessage_PeersEntry {
+  export function fromJSON(object: any): IslandChangedMessage_PeersEntry {
     return {
       key: isSet(object.key) ? String(object.key) : "",
-      value: isSet(object.value) ? Position3DMessage.fromJSON(object.value) : undefined,
+      value: isSet(object.value) ? Position.fromJSON(object.value) : undefined,
     };
-  },
+  }
 
-  toJSON(message: IslandChangedMessage_PeersEntry): unknown {
+  export function toJSON(message: IslandChangedMessage_PeersEntry): unknown {
     const obj: any = {};
     message.key !== undefined && (obj.key = message.key);
-    message.value !== undefined && (obj.value = message.value ? Position3DMessage.toJSON(message.value) : undefined);
+    message.value !== undefined && (obj.value = message.value ? Position.toJSON(message.value) : undefined);
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<IslandChangedMessage_PeersEntry>, I>>(
+    base?: I,
+  ): IslandChangedMessage_PeersEntry {
+    return IslandChangedMessage_PeersEntry.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<IslandChangedMessage_PeersEntry>, I>>(
+  export function fromPartial<I extends Exact<DeepPartial<IslandChangedMessage_PeersEntry>, I>>(
     object: I,
   ): IslandChangedMessage_PeersEntry {
     const message = createBaseIslandChangedMessage_PeersEntry();
     message.key = object.key ?? "";
     message.value = (object.value !== undefined && object.value !== null)
-      ? Position3DMessage.fromPartial(object.value)
+      ? Position.fromPartial(object.value)
       : undefined;
     return message;
-  },
-};
+  }
+}
 
 function createBaseLeftIslandMessage(): LeftIslandMessage {
   return { islandId: "", peerId: "" };
 }
 
-export const LeftIslandMessage = {
-  encode(message: LeftIslandMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace LeftIslandMessage {
+  export function encode(message: LeftIslandMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.islandId !== "") {
       writer.uint32(10).string(message.islandId);
     }
@@ -348,57 +464,70 @@ export const LeftIslandMessage = {
       writer.uint32(18).string(message.peerId);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): LeftIslandMessage {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): LeftIslandMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseLeftIslandMessage();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 10) {
+            break;
+          }
+
           message.islandId = reader.string();
-          break;
+          continue;
         case 2:
+          if (tag !== 18) {
+            break;
+          }
+
           message.peerId = 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): LeftIslandMessage {
+  export function fromJSON(object: any): LeftIslandMessage {
     return {
       islandId: isSet(object.islandId) ? String(object.islandId) : "",
       peerId: isSet(object.peerId) ? String(object.peerId) : "",
     };
-  },
+  }
 
-  toJSON(message: LeftIslandMessage): unknown {
+  export function toJSON(message: LeftIslandMessage): unknown {
     const obj: any = {};
     message.islandId !== undefined && (obj.islandId = message.islandId);
     message.peerId !== undefined && (obj.peerId = message.peerId);
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<LeftIslandMessage>, I>>(base?: I): LeftIslandMessage {
+    return LeftIslandMessage.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<LeftIslandMessage>, I>>(object: I): LeftIslandMessage {
+  export function fromPartial<I extends Exact<DeepPartial<LeftIslandMessage>, I>>(object: I): LeftIslandMessage {
     const message = createBaseLeftIslandMessage();
     message.islandId = object.islandId ?? "";
     message.peerId = object.peerId ?? "";
     return message;
-  },
-};
+  }
+}
 
 function createBaseJoinIslandMessage(): JoinIslandMessage {
   return { islandId: "", peerId: "" };
 }
 
-export const JoinIslandMessage = {
-  encode(message: JoinIslandMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace JoinIslandMessage {
+  export function encode(message: JoinIslandMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.islandId !== "") {
       writer.uint32(10).string(message.islandId);
     }
@@ -406,637 +535,977 @@ export const JoinIslandMessage = {
       writer.uint32(18).string(message.peerId);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): JoinIslandMessage {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): JoinIslandMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseJoinIslandMessage();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 10) {
+            break;
+          }
+
           message.islandId = reader.string();
-          break;
+          continue;
         case 2:
+          if (tag !== 18) {
+            break;
+          }
+
           message.peerId = 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): JoinIslandMessage {
+  export function fromJSON(object: any): JoinIslandMessage {
     return {
       islandId: isSet(object.islandId) ? String(object.islandId) : "",
       peerId: isSet(object.peerId) ? String(object.peerId) : "",
     };
-  },
+  }
 
-  toJSON(message: JoinIslandMessage): unknown {
+  export function toJSON(message: JoinIslandMessage): unknown {
     const obj: any = {};
     message.islandId !== undefined && (obj.islandId = message.islandId);
     message.peerId !== undefined && (obj.peerId = message.peerId);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<JoinIslandMessage>, I>>(object: I): JoinIslandMessage {
+  export function create<I extends Exact<DeepPartial<JoinIslandMessage>, I>>(base?: I): JoinIslandMessage {
+    return JoinIslandMessage.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<JoinIslandMessage>, I>>(object: I): JoinIslandMessage {
     const message = createBaseJoinIslandMessage();
     message.islandId = object.islandId ?? "";
     message.peerId = object.peerId ?? "";
     return message;
-  },
-};
+  }
+}
 
-function createBaseIslandData(): IslandData {
-  return { id: "", peers: [], maxPeers: 0, center: undefined, radius: 0 };
+function createBaseKickedMessage(): KickedMessage {
+  return { reason: 0 };
 }
 
-export const IslandData = {
-  encode(message: IslandData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.id !== "") {
-      writer.uint32(10).string(message.id);
-    }
-    for (const v of message.peers) {
-      writer.uint32(18).string(v!);
-    }
-    if (message.maxPeers !== 0) {
-      writer.uint32(24).uint32(message.maxPeers);
-    }
-    if (message.center !== undefined) {
-      Position3DMessage.encode(message.center, writer.uint32(34).fork()).ldelim();
-    }
-    if (message.radius !== 0) {
-      writer.uint32(41).double(message.radius);
+export namespace KickedMessage {
+  export function encode(message: KickedMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.reason !== 0) {
+      writer.uint32(8).int32(message.reason);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): IslandData {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): KickedMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseIslandData();
+    const message = createBaseKickedMessage();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.id = reader.string();
-          break;
-        case 2:
-          message.peers.push(reader.string());
-          break;
-        case 3:
-          message.maxPeers = reader.uint32();
-          break;
-        case 4:
-          message.center = Position3DMessage.decode(reader, reader.uint32());
-          break;
-        case 5:
-          message.radius = reader.double();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          if (tag !== 8) {
+            break;
+          }
+
+          message.reason = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): IslandData {
-    return {
-      id: isSet(object.id) ? String(object.id) : "",
-      peers: Array.isArray(object?.peers) ? object.peers.map((e: any) => String(e)) : [],
-      maxPeers: isSet(object.maxPeers) ? Number(object.maxPeers) : 0,
-      center: isSet(object.center) ? Position3DMessage.fromJSON(object.center) : undefined,
-      radius: isSet(object.radius) ? Number(object.radius) : 0,
-    };
-  },
+  export function fromJSON(object: any): KickedMessage {
+    return { reason: isSet(object.reason) ? kickedReasonFromJSON(object.reason) : 0 };
+  }
 
-  toJSON(message: IslandData): unknown {
+  export function toJSON(message: KickedMessage): unknown {
     const obj: any = {};
-    message.id !== undefined && (obj.id = message.id);
-    if (message.peers) {
-      obj.peers = message.peers.map((e) => e);
-    } else {
-      obj.peers = [];
-    }
-    message.maxPeers !== undefined && (obj.maxPeers = Math.round(message.maxPeers));
-    message.center !== undefined &&
-      (obj.center = message.center ? Position3DMessage.toJSON(message.center) : undefined);
-    message.radius !== undefined && (obj.radius = message.radius);
+    message.reason !== undefined && (obj.reason = kickedReasonToJSON(message.reason));
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<IslandData>, I>>(object: I): IslandData {
-    const message = createBaseIslandData();
-    message.id = object.id ?? "";
-    message.peers = object.peers?.map((e) => e) || [];
-    message.maxPeers = object.maxPeers ?? 0;
-    message.center = (object.center !== undefined && object.center !== null)
-      ? Position3DMessage.fromPartial(object.center)
-      : undefined;
-    message.radius = object.radius ?? 0;
+  export function create<I extends Exact<DeepPartial<KickedMessage>, I>>(base?: I): KickedMessage {
+    return KickedMessage.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<KickedMessage>, I>>(object: I): KickedMessage {
+    const message = createBaseKickedMessage();
+    message.reason = object.reason ?? 0;
     return message;
-  },
-};
+  }
+}
 
-function createBaseIslandStatusMessage(): IslandStatusMessage {
-  return { data: [] };
+function createBaseServerPacket(): ServerPacket {
+  return { message: undefined };
 }
 
-export const IslandStatusMessage = {
-  encode(message: IslandStatusMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    for (const v of message.data) {
-      IslandData.encode(v!, writer.uint32(10).fork()).ldelim();
+export namespace ServerPacket {
+  export function encode(message: ServerPacket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.message?.$case) {
+      case "challengeResponse":
+        ChallengeResponseMessage.encode(message.message.challengeResponse, writer.uint32(10).fork()).ldelim();
+        break;
+      case "welcome":
+        WelcomeMessage.encode(message.message.welcome, writer.uint32(18).fork()).ldelim();
+        break;
+      case "islandChanged":
+        IslandChangedMessage.encode(message.message.islandChanged, writer.uint32(26).fork()).ldelim();
+        break;
+      case "leftIsland":
+        LeftIslandMessage.encode(message.message.leftIsland, writer.uint32(34).fork()).ldelim();
+        break;
+      case "joinIsland":
+        JoinIslandMessage.encode(message.message.joinIsland, writer.uint32(42).fork()).ldelim();
+        break;
+      case "kicked":
+        KickedMessage.encode(message.message.kicked, writer.uint32(50).fork()).ldelim();
+        break;
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): IslandStatusMessage {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ServerPacket {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseIslandStatusMessage();
+    const message = createBaseServerPacket();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.data.push(IslandData.decode(reader, reader.uint32()));
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
+          if (tag !== 10) {
+            break;
+          }
 
-  fromJSON(object: any): IslandStatusMessage {
-    return { data: Array.isArray(object?.data) ? object.data.map((e: any) => IslandData.fromJSON(e)) : [] };
-  },
+          message.message = {
+            $case: "challengeResponse",
+            challengeResponse: ChallengeResponseMessage.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
 
-  toJSON(message: IslandStatusMessage): unknown {
-    const obj: any = {};
-    if (message.data) {
-      obj.data = message.data.map((e) => e ? IslandData.toJSON(e) : undefined);
-    } else {
-      obj.data = [];
-    }
-    return obj;
-  },
+          message.message = { $case: "welcome", welcome: WelcomeMessage.decode(reader, reader.uint32()) };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
 
-  fromPartial<I extends Exact<DeepPartial<IslandStatusMessage>, I>>(object: I): IslandStatusMessage {
-    const message = createBaseIslandStatusMessage();
-    message.data = object.data?.map((e) => IslandData.fromPartial(e)) || [];
-    return message;
-  },
-};
+          message.message = {
+            $case: "islandChanged",
+            islandChanged: IslandChangedMessage.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
 
-function createBaseTransportInit(): TransportInit {
-  return { type: 0, maxIslandSize: 0 };
-}
+          message.message = { $case: "leftIsland", leftIsland: LeftIslandMessage.decode(reader, reader.uint32()) };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
 
-export const TransportInit = {
-  encode(message: TransportInit, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.type !== 0) {
-      writer.uint32(8).int32(message.type);
-    }
-    if (message.maxIslandSize !== 0) {
-      writer.uint32(16).uint32(message.maxIslandSize);
-    }
-    return writer;
-  },
+          message.message = { $case: "joinIsland", joinIsland: JoinIslandMessage.decode(reader, reader.uint32()) };
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportInit {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportInit();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          message.type = reader.int32() as any;
-          break;
-        case 2:
-          message.maxIslandSize = reader.uint32();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          message.message = { $case: "kicked", kicked: KickedMessage.decode(reader, reader.uint32()) };
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): TransportInit {
+  export function fromJSON(object: any): ServerPacket {
     return {
-      type: isSet(object.type) ? transportTypeFromJSON(object.type) : 0,
-      maxIslandSize: isSet(object.maxIslandSize) ? Number(object.maxIslandSize) : 0,
+      message: isSet(object.challengeResponse)
+        ? { $case: "challengeResponse", challengeResponse: ChallengeResponseMessage.fromJSON(object.challengeResponse) }
+        : isSet(object.welcome)
+        ? { $case: "welcome", welcome: WelcomeMessage.fromJSON(object.welcome) }
+        : isSet(object.islandChanged)
+        ? { $case: "islandChanged", islandChanged: IslandChangedMessage.fromJSON(object.islandChanged) }
+        : isSet(object.leftIsland)
+        ? { $case: "leftIsland", leftIsland: LeftIslandMessage.fromJSON(object.leftIsland) }
+        : isSet(object.joinIsland)
+        ? { $case: "joinIsland", joinIsland: JoinIslandMessage.fromJSON(object.joinIsland) }
+        : isSet(object.kicked)
+        ? { $case: "kicked", kicked: KickedMessage.fromJSON(object.kicked) }
+        : undefined,
     };
-  },
+  }
 
-  toJSON(message: TransportInit): unknown {
+  export function toJSON(message: ServerPacket): unknown {
     const obj: any = {};
-    message.type !== undefined && (obj.type = transportTypeToJSON(message.type));
-    message.maxIslandSize !== undefined && (obj.maxIslandSize = Math.round(message.maxIslandSize));
+    message.message?.$case === "challengeResponse" &&
+      (obj.challengeResponse = message.message?.challengeResponse
+        ? ChallengeResponseMessage.toJSON(message.message?.challengeResponse)
+        : undefined);
+    message.message?.$case === "welcome" &&
+      (obj.welcome = message.message?.welcome ? WelcomeMessage.toJSON(message.message?.welcome) : undefined);
+    message.message?.$case === "islandChanged" &&
+      (obj.islandChanged = message.message?.islandChanged
+        ? IslandChangedMessage.toJSON(message.message?.islandChanged)
+        : undefined);
+    message.message?.$case === "leftIsland" &&
+      (obj.leftIsland = message.message?.leftIsland
+        ? LeftIslandMessage.toJSON(message.message?.leftIsland)
+        : undefined);
+    message.message?.$case === "joinIsland" &&
+      (obj.joinIsland = message.message?.joinIsland
+        ? JoinIslandMessage.toJSON(message.message?.joinIsland)
+        : undefined);
+    message.message?.$case === "kicked" &&
+      (obj.kicked = message.message?.kicked ? KickedMessage.toJSON(message.message?.kicked) : undefined);
     return obj;
-  },
-
-  fromPartial<I extends Exact<DeepPartial<TransportInit>, I>>(object: I): TransportInit {
-    const message = createBaseTransportInit();
-    message.type = object.type ?? 0;
-    message.maxIslandSize = object.maxIslandSize ?? 0;
-    return message;
-  },
-};
+  }
 
-function createBaseTransportHeartbeat(): TransportHeartbeat {
-  return { availableSeats: 0, usersCount: 0 };
-}
+  export function create<I extends Exact<DeepPartial<ServerPacket>, I>>(base?: I): ServerPacket {
+    return ServerPacket.fromPartial(base ?? {});
+  }
 
-export const TransportHeartbeat = {
-  encode(message: TransportHeartbeat, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.availableSeats !== 0) {
-      writer.uint32(8).uint32(message.availableSeats);
+  export function fromPartial<I extends Exact<DeepPartial<ServerPacket>, I>>(object: I): ServerPacket {
+    const message = createBaseServerPacket();
+    if (
+      object.message?.$case === "challengeResponse" &&
+      object.message?.challengeResponse !== undefined &&
+      object.message?.challengeResponse !== null
+    ) {
+      message.message = {
+        $case: "challengeResponse",
+        challengeResponse: ChallengeResponseMessage.fromPartial(object.message.challengeResponse),
+      };
     }
-    if (message.usersCount !== 0) {
-      writer.uint32(16).uint32(message.usersCount);
+    if (
+      object.message?.$case === "welcome" && object.message?.welcome !== undefined && object.message?.welcome !== null
+    ) {
+      message.message = { $case: "welcome", welcome: WelcomeMessage.fromPartial(object.message.welcome) };
     }
-    return writer;
-  },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportHeartbeat {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportHeartbeat();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          message.availableSeats = reader.uint32();
-          break;
-        case 2:
-          message.usersCount = reader.uint32();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+    if (
+      object.message?.$case === "islandChanged" &&
+      object.message?.islandChanged !== undefined &&
+      object.message?.islandChanged !== null
+    ) {
+      message.message = {
+        $case: "islandChanged",
+        islandChanged: IslandChangedMessage.fromPartial(object.message.islandChanged),
+      };
+    }
+    if (
+      object.message?.$case === "leftIsland" &&
+      object.message?.leftIsland !== undefined &&
+      object.message?.leftIsland !== null
+    ) {
+      message.message = { $case: "leftIsland", leftIsland: LeftIslandMessage.fromPartial(object.message.leftIsland) };
+    }
+    if (
+      object.message?.$case === "joinIsland" &&
+      object.message?.joinIsland !== undefined &&
+      object.message?.joinIsland !== null
+    ) {
+      message.message = { $case: "joinIsland", joinIsland: JoinIslandMessage.fromPartial(object.message.joinIsland) };
+    }
+    if (object.message?.$case === "kicked" && object.message?.kicked !== undefined && object.message?.kicked !== null) {
+      message.message = { $case: "kicked", kicked: KickedMessage.fromPartial(object.message.kicked) };
+    }
+    return message;
+  }
+}
+
+function createBaseChallengeRequestMessage(): ChallengeRequestMessage {
+  return { address: "" };
+}
+
+export namespace ChallengeRequestMessage {
+  export function encode(message: ChallengeRequestMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ChallengeRequestMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseChallengeRequestMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.address = reader.string();
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): TransportHeartbeat {
-    return {
-      availableSeats: isSet(object.availableSeats) ? Number(object.availableSeats) : 0,
-      usersCount: isSet(object.usersCount) ? Number(object.usersCount) : 0,
-    };
-  },
+  export function fromJSON(object: any): ChallengeRequestMessage {
+    return { address: isSet(object.address) ? String(object.address) : "" };
+  }
 
-  toJSON(message: TransportHeartbeat): unknown {
+  export function toJSON(message: ChallengeRequestMessage): unknown {
     const obj: any = {};
-    message.availableSeats !== undefined && (obj.availableSeats = Math.round(message.availableSeats));
-    message.usersCount !== undefined && (obj.usersCount = Math.round(message.usersCount));
+    message.address !== undefined && (obj.address = message.address);
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<ChallengeRequestMessage>, I>>(base?: I): ChallengeRequestMessage {
+    return ChallengeRequestMessage.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<TransportHeartbeat>, I>>(object: I): TransportHeartbeat {
-    const message = createBaseTransportHeartbeat();
-    message.availableSeats = object.availableSeats ?? 0;
-    message.usersCount = object.usersCount ?? 0;
+  export function fromPartial<I extends Exact<DeepPartial<ChallengeRequestMessage>, I>>(
+    object: I,
+  ): ChallengeRequestMessage {
+    const message = createBaseChallengeRequestMessage();
+    message.address = object.address ?? "";
     return message;
-  },
-};
+  }
+}
 
-function createBaseTransportAuthorizationRequest(): TransportAuthorizationRequest {
-  return { requestId: "", roomId: "", userIds: [] };
+function createBaseSignedChallengeMessage(): SignedChallengeMessage {
+  return { authChainJson: "" };
 }
 
-export const TransportAuthorizationRequest = {
-  encode(message: TransportAuthorizationRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.requestId !== "") {
-      writer.uint32(10).string(message.requestId);
+export namespace SignedChallengeMessage {
+  export function encode(message: SignedChallengeMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authChainJson !== "") {
+      writer.uint32(10).string(message.authChainJson);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SignedChallengeMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSignedChallengeMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.authChainJson = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
-    if (message.roomId !== "") {
-      writer.uint32(18).string(message.roomId);
+    return message;
+  }
+
+  export function fromJSON(object: any): SignedChallengeMessage {
+    return { authChainJson: isSet(object.authChainJson) ? String(object.authChainJson) : "" };
+  }
+
+  export function toJSON(message: SignedChallengeMessage): unknown {
+    const obj: any = {};
+    message.authChainJson !== undefined && (obj.authChainJson = message.authChainJson);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SignedChallengeMessage>, I>>(base?: I): SignedChallengeMessage {
+    return SignedChallengeMessage.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SignedChallengeMessage>, I>>(
+    object: I,
+  ): SignedChallengeMessage {
+    const message = createBaseSignedChallengeMessage();
+    message.authChainJson = object.authChainJson ?? "";
+    return message;
+  }
+}
+
+function createBaseHeartbeat(): Heartbeat {
+  return { position: undefined, desiredRoom: undefined };
+}
+
+export namespace Heartbeat {
+  export function encode(message: Heartbeat, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.position !== undefined) {
+      Position.encode(message.position, writer.uint32(10).fork()).ldelim();
     }
-    for (const v of message.userIds) {
-      writer.uint32(26).string(v!);
+    if (message.desiredRoom !== undefined) {
+      writer.uint32(18).string(message.desiredRoom);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportAuthorizationRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Heartbeat {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportAuthorizationRequest();
+    const message = createBaseHeartbeat();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.requestId = reader.string();
-          break;
+          if (tag !== 10) {
+            break;
+          }
+
+          message.position = Position.decode(reader, reader.uint32());
+          continue;
         case 2:
-          message.roomId = reader.string();
-          break;
-        case 3:
-          message.userIds.push(reader.string());
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          if (tag !== 18) {
+            break;
+          }
+
+          message.desiredRoom = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): TransportAuthorizationRequest {
+  export function fromJSON(object: any): Heartbeat {
     return {
-      requestId: isSet(object.requestId) ? String(object.requestId) : "",
-      roomId: isSet(object.roomId) ? String(object.roomId) : "",
-      userIds: Array.isArray(object?.userIds) ? object.userIds.map((e: any) => String(e)) : [],
+      position: isSet(object.position) ? Position.fromJSON(object.position) : undefined,
+      desiredRoom: isSet(object.desiredRoom) ? String(object.desiredRoom) : undefined,
     };
-  },
+  }
 
-  toJSON(message: TransportAuthorizationRequest): unknown {
+  export function toJSON(message: Heartbeat): unknown {
     const obj: any = {};
-    message.requestId !== undefined && (obj.requestId = message.requestId);
-    message.roomId !== undefined && (obj.roomId = message.roomId);
-    if (message.userIds) {
-      obj.userIds = message.userIds.map((e) => e);
-    } else {
-      obj.userIds = [];
-    }
+    message.position !== undefined && (obj.position = message.position ? Position.toJSON(message.position) : undefined);
+    message.desiredRoom !== undefined && (obj.desiredRoom = message.desiredRoom);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<TransportAuthorizationRequest>, I>>(
-    object: I,
-  ): TransportAuthorizationRequest {
-    const message = createBaseTransportAuthorizationRequest();
-    message.requestId = object.requestId ?? "";
-    message.roomId = object.roomId ?? "";
-    message.userIds = object.userIds?.map((e) => e) || [];
+  export function create<I extends Exact<DeepPartial<Heartbeat>, I>>(base?: I): Heartbeat {
+    return Heartbeat.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Heartbeat>, I>>(object: I): Heartbeat {
+    const message = createBaseHeartbeat();
+    message.position = (object.position !== undefined && object.position !== null)
+      ? Position.fromPartial(object.position)
+      : undefined;
+    message.desiredRoom = object.desiredRoom ?? undefined;
     return message;
-  },
-};
+  }
+}
 
-function createBaseTransportAuthorizationResponse(): TransportAuthorizationResponse {
-  return { requestId: "", connStrs: {} };
+function createBaseClientPacket(): ClientPacket {
+  return { message: undefined };
 }
 
-export const TransportAuthorizationResponse = {
-  encode(message: TransportAuthorizationResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.requestId !== "") {
-      writer.uint32(10).string(message.requestId);
+export namespace ClientPacket {
+  export function encode(message: ClientPacket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.message?.$case) {
+      case "challengeRequest":
+        ChallengeRequestMessage.encode(message.message.challengeRequest, writer.uint32(10).fork()).ldelim();
+        break;
+      case "signedChallenge":
+        SignedChallengeMessage.encode(message.message.signedChallenge, writer.uint32(18).fork()).ldelim();
+        break;
+      case "heartbeat":
+        Heartbeat.encode(message.message.heartbeat, writer.uint32(26).fork()).ldelim();
+        break;
     }
-    Object.entries(message.connStrs).forEach(([key, value]) => {
-      TransportAuthorizationResponse_ConnStrsEntry.encode({ key: key as any, value }, writer.uint32(18).fork())
-        .ldelim();
-    });
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportAuthorizationResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ClientPacket {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportAuthorizationResponse();
+    const message = createBaseClientPacket();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.requestId = reader.string();
-          break;
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = {
+            $case: "challengeRequest",
+            challengeRequest: ChallengeRequestMessage.decode(reader, reader.uint32()),
+          };
+          continue;
         case 2:
-          const entry2 = TransportAuthorizationResponse_ConnStrsEntry.decode(reader, reader.uint32());
-          if (entry2.value !== undefined) {
-            message.connStrs[entry2.key] = entry2.value;
+          if (tag !== 18) {
+            break;
+          }
+
+          message.message = {
+            $case: "signedChallenge",
+            signedChallenge: SignedChallengeMessage.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
           }
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+
+          message.message = { $case: "heartbeat", heartbeat: Heartbeat.decode(reader, reader.uint32()) };
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): TransportAuthorizationResponse {
+  export function fromJSON(object: any): ClientPacket {
     return {
-      requestId: isSet(object.requestId) ? String(object.requestId) : "",
-      connStrs: isObject(object.connStrs)
-        ? Object.entries(object.connStrs).reduce<{ [key: string]: string }>((acc, [key, value]) => {
-          acc[key] = String(value);
-          return acc;
-        }, {})
-        : {},
+      message: isSet(object.challengeRequest)
+        ? { $case: "challengeRequest", challengeRequest: ChallengeRequestMessage.fromJSON(object.challengeRequest) }
+        : isSet(object.signedChallenge)
+        ? { $case: "signedChallenge", signedChallenge: SignedChallengeMessage.fromJSON(object.signedChallenge) }
+        : isSet(object.heartbeat)
+        ? { $case: "heartbeat", heartbeat: Heartbeat.fromJSON(object.heartbeat) }
+        : undefined,
     };
-  },
+  }
 
-  toJSON(message: TransportAuthorizationResponse): unknown {
+  export function toJSON(message: ClientPacket): unknown {
     const obj: any = {};
-    message.requestId !== undefined && (obj.requestId = message.requestId);
-    obj.connStrs = {};
-    if (message.connStrs) {
-      Object.entries(message.connStrs).forEach(([k, v]) => {
-        obj.connStrs[k] = v;
-      });
-    }
+    message.message?.$case === "challengeRequest" &&
+      (obj.challengeRequest = message.message?.challengeRequest
+        ? ChallengeRequestMessage.toJSON(message.message?.challengeRequest)
+        : undefined);
+    message.message?.$case === "signedChallenge" &&
+      (obj.signedChallenge = message.message?.signedChallenge
+        ? SignedChallengeMessage.toJSON(message.message?.signedChallenge)
+        : undefined);
+    message.message?.$case === "heartbeat" &&
+      (obj.heartbeat = message.message?.heartbeat ? Heartbeat.toJSON(message.message?.heartbeat) : undefined);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<TransportAuthorizationResponse>, I>>(
-    object: I,
-  ): TransportAuthorizationResponse {
-    const message = createBaseTransportAuthorizationResponse();
-    message.requestId = object.requestId ?? "";
-    message.connStrs = Object.entries(object.connStrs ?? {}).reduce<{ [key: string]: string }>((acc, [key, value]) => {
-      if (value !== undefined) {
-        acc[key] = String(value);
-      }
-      return acc;
-    }, {});
+  export function create<I extends Exact<DeepPartial<ClientPacket>, I>>(base?: I): ClientPacket {
+    return ClientPacket.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ClientPacket>, I>>(object: I): ClientPacket {
+    const message = createBaseClientPacket();
+    if (
+      object.message?.$case === "challengeRequest" &&
+      object.message?.challengeRequest !== undefined &&
+      object.message?.challengeRequest !== null
+    ) {
+      message.message = {
+        $case: "challengeRequest",
+        challengeRequest: ChallengeRequestMessage.fromPartial(object.message.challengeRequest),
+      };
+    }
+    if (
+      object.message?.$case === "signedChallenge" &&
+      object.message?.signedChallenge !== undefined &&
+      object.message?.signedChallenge !== null
+    ) {
+      message.message = {
+        $case: "signedChallenge",
+        signedChallenge: SignedChallengeMessage.fromPartial(object.message.signedChallenge),
+      };
+    }
+    if (
+      object.message?.$case === "heartbeat" &&
+      object.message?.heartbeat !== undefined &&
+      object.message?.heartbeat !== null
+    ) {
+      message.message = { $case: "heartbeat", heartbeat: Heartbeat.fromPartial(object.message.heartbeat) };
+    }
     return message;
-  },
-};
+  }
+}
 
-function createBaseTransportAuthorizationResponse_ConnStrsEntry(): TransportAuthorizationResponse_ConnStrsEntry {
-  return { key: "", value: "" };
+function createBaseIslandData(): IslandData {
+  return { id: "", peers: [], maxPeers: 0, center: undefined, radius: 0 };
 }
 
-export const TransportAuthorizationResponse_ConnStrsEntry = {
-  encode(message: TransportAuthorizationResponse_ConnStrsEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.key !== "") {
-      writer.uint32(10).string(message.key);
+export namespace IslandData {
+  export function encode(message: IslandData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    for (const v of message.peers) {
+      writer.uint32(18).string(v!);
+    }
+    if (message.maxPeers !== 0) {
+      writer.uint32(24).uint32(message.maxPeers);
     }
-    if (message.value !== "") {
-      writer.uint32(18).string(message.value);
+    if (message.center !== undefined) {
+      Position.encode(message.center, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.radius !== 0) {
+      writer.uint32(41).double(message.radius);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportAuthorizationResponse_ConnStrsEntry {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): IslandData {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportAuthorizationResponse_ConnStrsEntry();
+    const message = createBaseIslandData();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.key = reader.string();
-          break;
+          if (tag !== 10) {
+            break;
+          }
+
+          message.id = reader.string();
+          continue;
         case 2:
-          message.value = reader.string();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          if (tag !== 18) {
+            break;
+          }
+
+          message.peers.push(reader.string());
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.maxPeers = reader.uint32();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.center = Position.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 41) {
+            break;
+          }
+
+          message.radius = reader.double();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): TransportAuthorizationResponse_ConnStrsEntry {
-    return { key: isSet(object.key) ? String(object.key) : "", value: isSet(object.value) ? String(object.value) : "" };
-  },
+  export function fromJSON(object: any): IslandData {
+    return {
+      id: isSet(object.id) ? String(object.id) : "",
+      peers: Array.isArray(object?.peers) ? object.peers.map((e: any) => String(e)) : [],
+      maxPeers: isSet(object.maxPeers) ? Number(object.maxPeers) : 0,
+      center: isSet(object.center) ? Position.fromJSON(object.center) : undefined,
+      radius: isSet(object.radius) ? Number(object.radius) : 0,
+    };
+  }
 
-  toJSON(message: TransportAuthorizationResponse_ConnStrsEntry): unknown {
+  export function toJSON(message: IslandData): unknown {
     const obj: any = {};
-    message.key !== undefined && (obj.key = message.key);
-    message.value !== undefined && (obj.value = message.value);
+    message.id !== undefined && (obj.id = message.id);
+    if (message.peers) {
+      obj.peers = message.peers.map((e) => e);
+    } else {
+      obj.peers = [];
+    }
+    message.maxPeers !== undefined && (obj.maxPeers = Math.round(message.maxPeers));
+    message.center !== undefined && (obj.center = message.center ? Position.toJSON(message.center) : undefined);
+    message.radius !== undefined && (obj.radius = message.radius);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<TransportAuthorizationResponse_ConnStrsEntry>, I>>(
-    object: I,
-  ): TransportAuthorizationResponse_ConnStrsEntry {
-    const message = createBaseTransportAuthorizationResponse_ConnStrsEntry();
-    message.key = object.key ?? "";
-    message.value = object.value ?? "";
+  export function create<I extends Exact<DeepPartial<IslandData>, I>>(base?: I): IslandData {
+    return IslandData.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<IslandData>, I>>(object: I): IslandData {
+    const message = createBaseIslandData();
+    message.id = object.id ?? "";
+    message.peers = object.peers?.map((e) => e) || [];
+    message.maxPeers = object.maxPeers ?? 0;
+    message.center = (object.center !== undefined && object.center !== null)
+      ? Position.fromPartial(object.center)
+      : undefined;
+    message.radius = object.radius ?? 0;
     return message;
-  },
-};
+  }
+}
 
-function createBaseTransportMessage(): TransportMessage {
-  return { message: undefined };
+function createBaseIslandStatusMessage(): IslandStatusMessage {
+  return { data: [] };
 }
 
-export const TransportMessage = {
-  encode(message: TransportMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.message?.$case === "init") {
-      TransportInit.encode(message.message.init, writer.uint32(10).fork()).ldelim();
+export namespace IslandStatusMessage {
+  export function encode(message: IslandStatusMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.data) {
+      IslandData.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): IslandStatusMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIslandStatusMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.data.push(IslandData.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): IslandStatusMessage {
+    return { data: Array.isArray(object?.data) ? object.data.map((e: any) => IslandData.fromJSON(e)) : [] };
+  }
+
+  export function toJSON(message: IslandStatusMessage): unknown {
+    const obj: any = {};
+    if (message.data) {
+      obj.data = message.data.map((e) => e ? IslandData.toJSON(e) : undefined);
+    } else {
+      obj.data = [];
     }
-    if (message.message?.$case === "heartbeat") {
-      TransportHeartbeat.encode(message.message.heartbeat, writer.uint32(18).fork()).ldelim();
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<IslandStatusMessage>, I>>(base?: I): IslandStatusMessage {
+    return IslandStatusMessage.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<IslandStatusMessage>, I>>(object: I): IslandStatusMessage {
+    const message = createBaseIslandStatusMessage();
+    message.data = object.data?.map((e) => IslandData.fromPartial(e)) || [];
+    return message;
+  }
+}
+
+function createBaseServiceStatus(): ServiceStatus {
+  return { currentTime: 0, commitHash: undefined, userCount: 0 };
+}
+
+export namespace ServiceStatus {
+  export function encode(message: ServiceStatus, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.currentTime !== 0) {
+      writer.uint32(8).uint64(message.currentTime);
     }
-    if (message.message?.$case === "authRequest") {
-      TransportAuthorizationRequest.encode(message.message.authRequest, writer.uint32(26).fork()).ldelim();
+    if (message.commitHash !== undefined) {
+      writer.uint32(18).string(message.commitHash);
     }
-    if (message.message?.$case === "authResponse") {
-      TransportAuthorizationResponse.encode(message.message.authResponse, writer.uint32(34).fork()).ldelim();
+    if (message.userCount !== 0) {
+      writer.uint32(24).uint32(message.userCount);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportMessage {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ServiceStatus {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportMessage();
+    const message = createBaseServiceStatus();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.message = { $case: "init", init: TransportInit.decode(reader, reader.uint32()) };
-          break;
+          if (tag !== 8) {
+            break;
+          }
+
+          message.currentTime = longToNumber(reader.uint64() as Long);
+          continue;
         case 2:
-          message.message = { $case: "heartbeat", heartbeat: TransportHeartbeat.decode(reader, reader.uint32()) };
-          break;
+          if (tag !== 18) {
+            break;
+          }
+
+          message.commitHash = reader.string();
+          continue;
         case 3:
-          message.message = {
-            $case: "authRequest",
-            authRequest: TransportAuthorizationRequest.decode(reader, reader.uint32()),
-          };
-          break;
-        case 4:
-          message.message = {
-            $case: "authResponse",
-            authResponse: TransportAuthorizationResponse.decode(reader, reader.uint32()),
-          };
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          if (tag !== 24) {
+            break;
+          }
+
+          message.userCount = reader.uint32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): TransportMessage {
+  export function fromJSON(object: any): ServiceStatus {
     return {
-      message: isSet(object.init)
-        ? { $case: "init", init: TransportInit.fromJSON(object.init) }
-        : isSet(object.heartbeat)
-        ? { $case: "heartbeat", heartbeat: TransportHeartbeat.fromJSON(object.heartbeat) }
-        : isSet(object.authRequest)
-        ? { $case: "authRequest", authRequest: TransportAuthorizationRequest.fromJSON(object.authRequest) }
-        : isSet(object.authResponse)
-        ? { $case: "authResponse", authResponse: TransportAuthorizationResponse.fromJSON(object.authResponse) }
-        : undefined,
+      currentTime: isSet(object.currentTime) ? Number(object.currentTime) : 0,
+      commitHash: isSet(object.commitHash) ? String(object.commitHash) : undefined,
+      userCount: isSet(object.userCount) ? Number(object.userCount) : 0,
     };
-  },
+  }
 
-  toJSON(message: TransportMessage): unknown {
+  export function toJSON(message: ServiceStatus): unknown {
     const obj: any = {};
-    message.message?.$case === "init" &&
-      (obj.init = message.message?.init ? TransportInit.toJSON(message.message?.init) : undefined);
-    message.message?.$case === "heartbeat" &&
-      (obj.heartbeat = message.message?.heartbeat ? TransportHeartbeat.toJSON(message.message?.heartbeat) : undefined);
-    message.message?.$case === "authRequest" && (obj.authRequest = message.message?.authRequest
-      ? TransportAuthorizationRequest.toJSON(message.message?.authRequest)
-      : undefined);
-    message.message?.$case === "authResponse" && (obj.authResponse = message.message?.authResponse
-      ? TransportAuthorizationResponse.toJSON(message.message?.authResponse)
-      : undefined);
+    message.currentTime !== undefined && (obj.currentTime = Math.round(message.currentTime));
+    message.commitHash !== undefined && (obj.commitHash = message.commitHash);
+    message.userCount !== undefined && (obj.userCount = Math.round(message.userCount));
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<TransportMessage>, I>>(object: I): TransportMessage {
-    const message = createBaseTransportMessage();
-    if (object.message?.$case === "init" && object.message?.init !== undefined && object.message?.init !== null) {
-      message.message = { $case: "init", init: TransportInit.fromPartial(object.message.init) };
-    }
-    if (
-      object.message?.$case === "heartbeat" &&
-      object.message?.heartbeat !== undefined &&
-      object.message?.heartbeat !== null
-    ) {
-      message.message = { $case: "heartbeat", heartbeat: TransportHeartbeat.fromPartial(object.message.heartbeat) };
+  export function create<I extends Exact<DeepPartial<ServiceStatus>, I>>(base?: I): ServiceStatus {
+    return ServiceStatus.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ServiceStatus>, I>>(object: I): ServiceStatus {
+    const message = createBaseServiceStatus();
+    message.currentTime = object.currentTime ?? 0;
+    message.commitHash = object.commitHash ?? undefined;
+    message.userCount = object.userCount ?? 0;
+    return message;
+  }
+}
+
+function createBaseServiceDiscoveryMessage(): ServiceDiscoveryMessage {
+  return { serverName: "", status: undefined };
+}
+
+export namespace ServiceDiscoveryMessage {
+  export function encode(message: ServiceDiscoveryMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.serverName !== "") {
+      writer.uint32(10).string(message.serverName);
     }
-    if (
-      object.message?.$case === "authRequest" &&
-      object.message?.authRequest !== undefined &&
-      object.message?.authRequest !== null
-    ) {
-      message.message = {
-        $case: "authRequest",
-        authRequest: TransportAuthorizationRequest.fromPartial(object.message.authRequest),
-      };
+    if (message.status !== undefined) {
+      ServiceStatus.encode(message.status, writer.uint32(18).fork()).ldelim();
     }
-    if (
-      object.message?.$case === "authResponse" &&
-      object.message?.authResponse !== undefined &&
-      object.message?.authResponse !== null
-    ) {
-      message.message = {
-        $case: "authResponse",
-        authResponse: TransportAuthorizationResponse.fromPartial(object.message.authResponse),
-      };
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ServiceDiscoveryMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseServiceDiscoveryMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.serverName = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.status = ServiceStatus.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
-};
+  }
+
+  export function fromJSON(object: any): ServiceDiscoveryMessage {
+    return {
+      serverName: isSet(object.serverName) ? String(object.serverName) : "",
+      status: isSet(object.status) ? ServiceStatus.fromJSON(object.status) : undefined,
+    };
+  }
+
+  export function toJSON(message: ServiceDiscoveryMessage): unknown {
+    const obj: any = {};
+    message.serverName !== undefined && (obj.serverName = message.serverName);
+    message.status !== undefined && (obj.status = message.status ? ServiceStatus.toJSON(message.status) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ServiceDiscoveryMessage>, I>>(base?: I): ServiceDiscoveryMessage {
+    return ServiceDiscoveryMessage.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ServiceDiscoveryMessage>, I>>(
+    object: I,
+  ): ServiceDiscoveryMessage {
+    const message = createBaseServiceDiscoveryMessage();
+    message.serverName = object.serverName ?? "";
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ServiceStatus.fromPartial(object.status)
+      : undefined;
+    return message;
+  }
+}
+
+declare const self: any | undefined;
+declare const window: any | undefined;
+declare const global: any | undefined;
+const tsProtoGlobalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
 
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 
@@ -1050,6 +1519,18 @@ type KeysOfUnion<T> = T extends T ? keyof T : never;
 export type Exact<P, I extends P> = P extends Builtin ? P
   : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
 
+function longToNumber(long: Long): number {
+  if (long.gt(Number.MAX_SAFE_INTEGER)) {
+    throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
 function isObject(value: any): boolean {
   return typeof value === "object" && value !== null;
 }