@dcl/protocol 1.0.0-3160772301.commit-334e7a1 → 1.0.0-31617402096.commit-86c4613

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

@@ -0,0 +1,1540 @@
+/* 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 KickedReason {
+  KR_NEW_SESSION = 0,
+  UNRECOGNIZED = -1,
+}
+
+export function kickedReasonFromJSON(object: any): KickedReason {
+  switch (object) {
+    case 0:
+    case "KR_NEW_SESSION":
+      return KickedReason.KR_NEW_SESSION;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return KickedReason.UNRECOGNIZED;
+  }
+}
+
+export function kickedReasonToJSON(object: KickedReason): string {
+  switch (object) {
+    case KickedReason.KR_NEW_SESSION:
+      return "KR_NEW_SESSION";
+    case KickedReason.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/** 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]: Position };
+}
+
+export interface IslandChangedMessage_PeersEntry {
+  key: string;
+  value: Position | undefined;
+}
+
+export interface LeftIslandMessage {
+  islandId: string;
+  peerId: string;
+}
+
+export interface JoinIslandMessage {
+  islandId: string;
+  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: Position | undefined;
+  radius: number;
+}
+
+export interface IslandStatusMessage {
+  data: IslandData[];
+}
+
+export interface ServiceStatus {
+  currentTime: number;
+  commitHash?: string | undefined;
+  userCount: number;
+}
+
+export interface ServiceDiscoveryMessage {
+  serverName: string;
+  status: ServiceStatus | undefined;
+}
+
+function createBaseChallengeResponseMessage(): ChallengeResponseMessage {
+  return { challengeToSign: "", alreadyConnected: false };
+}
+
+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 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 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 createBaseWelcomeMessage(): WelcomeMessage {
+  return { peerId: "" };
+}
+
+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;
+  }
+
+  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 = createBaseWelcomeMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.peerId = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WelcomeMessage {
+    return { peerId: isSet(object.peerId) ? String(object.peerId) : "" };
+  }
+
+  export function toJSON(message: WelcomeMessage): unknown {
+    const obj: any = {};
+    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 ?? {});
+  }
+
+  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 namespace IslandChangedMessage {
+  export function encode(message: IslandChangedMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.islandId !== "") {
+      writer.uint32(10).string(message.islandId);
+    }
+    if (message.connStr !== "") {
+      writer.uint32(18).string(message.connStr);
+    }
+    if (message.fromIslandId !== undefined) {
+      writer.uint32(26).string(message.fromIslandId);
+    }
+    Object.entries(message.peers).forEach(([key, value]) => {
+      IslandChangedMessage_PeersEntry.encode({ key: key as any, value }, writer.uint32(34).fork()).ldelim();
+    });
+    return writer;
+  }
+
+  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();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.connStr = reader.string();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.fromIslandId = reader.string();
+          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;
+          }
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  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]: Position }>((acc, [key, value]) => {
+          acc[key] = Position.fromJSON(value);
+          return acc;
+        }, {})
+        : {},
+    };
+  }
+
+  export function toJSON(message: IslandChangedMessage): unknown {
+    const obj: any = {};
+    message.islandId !== undefined && (obj.islandId = message.islandId);
+    message.connStr !== undefined && (obj.connStr = message.connStr);
+    message.fromIslandId !== undefined && (obj.fromIslandId = message.fromIslandId);
+    obj.peers = {};
+    if (message.peers) {
+      Object.entries(message.peers).forEach(([k, v]) => {
+        obj.peers[k] = Position.toJSON(v);
+      });
+    }
+    return obj;
+  }
+
+  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]: 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 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) {
+      Position.encode(message.value, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  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();
+          continue;
+        case 2:
+          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;
+  }
+
+  export function fromJSON(object: any): IslandChangedMessage_PeersEntry {
+    return {
+      key: isSet(object.key) ? String(object.key) : "",
+      value: isSet(object.value) ? Position.fromJSON(object.value) : undefined,
+    };
+  }
+
+  export function toJSON(message: IslandChangedMessage_PeersEntry): unknown {
+    const obj: any = {};
+    message.key !== undefined && (obj.key = message.key);
+    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 ?? {});
+  }
+
+  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)
+      ? Position.fromPartial(object.value)
+      : undefined;
+    return message;
+  }
+}
+
+function createBaseLeftIslandMessage(): LeftIslandMessage {
+  return { islandId: "", peerId: "" };
+}
+
+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);
+    }
+    if (message.peerId !== "") {
+      writer.uint32(18).string(message.peerId);
+    }
+    return writer;
+  }
+
+  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();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.peerId = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): LeftIslandMessage {
+    return {
+      islandId: isSet(object.islandId) ? String(object.islandId) : "",
+      peerId: isSet(object.peerId) ? String(object.peerId) : "",
+    };
+  }
+
+  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 ?? {});
+  }
+
+  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 namespace JoinIslandMessage {
+  export function encode(message: JoinIslandMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.islandId !== "") {
+      writer.uint32(10).string(message.islandId);
+    }
+    if (message.peerId !== "") {
+      writer.uint32(18).string(message.peerId);
+    }
+    return writer;
+  }
+
+  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();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.peerId = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): JoinIslandMessage {
+    return {
+      islandId: isSet(object.islandId) ? String(object.islandId) : "",
+      peerId: isSet(object.peerId) ? String(object.peerId) : "",
+    };
+  }
+
+  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;
+  }
+
+  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 createBaseKickedMessage(): KickedMessage {
+  return { reason: 0 };
+}
+
+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;
+  }
+
+  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 = createBaseKickedMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.reason = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): KickedMessage {
+    return { reason: isSet(object.reason) ? kickedReasonFromJSON(object.reason) : 0 };
+  }
+
+  export function toJSON(message: KickedMessage): unknown {
+    const obj: any = {};
+    message.reason !== undefined && (obj.reason = kickedReasonToJSON(message.reason));
+    return obj;
+  }
+
+  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 createBaseServerPacket(): ServerPacket {
+  return { message: undefined };
+}
+
+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;
+  }
+
+  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 = createBaseServerPacket();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = {
+            $case: "challengeResponse",
+            challengeResponse: ChallengeResponseMessage.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.message = { $case: "welcome", welcome: WelcomeMessage.decode(reader, reader.uint32()) };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.message = {
+            $case: "islandChanged",
+            islandChanged: IslandChangedMessage.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.message = { $case: "leftIsland", leftIsland: LeftIslandMessage.decode(reader, reader.uint32()) };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.message = { $case: "joinIsland", joinIsland: JoinIslandMessage.decode(reader, reader.uint32()) };
+          continue;
+        case 6:
+          if (tag !== 50) {
+            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;
+  }
+
+  export function fromJSON(object: any): ServerPacket {
+    return {
+      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,
+    };
+  }
+
+  export function toJSON(message: ServerPacket): unknown {
+    const obj: any = {};
+    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;
+  }
+
+  export function create<I extends Exact<DeepPartial<ServerPacket>, I>>(base?: I): ServerPacket {
+    return ServerPacket.fromPartial(base ?? {});
+  }
+
+  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 (
+      object.message?.$case === "welcome" && object.message?.welcome !== undefined && object.message?.welcome !== null
+    ) {
+      message.message = { $case: "welcome", welcome: WelcomeMessage.fromPartial(object.message.welcome) };
+    }
+    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;
+  }
+
+  export function fromJSON(object: any): ChallengeRequestMessage {
+    return { address: isSet(object.address) ? String(object.address) : "" };
+  }
+
+  export function toJSON(message: ChallengeRequestMessage): unknown {
+    const obj: any = {};
+    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 ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ChallengeRequestMessage>, I>>(
+    object: I,
+  ): ChallengeRequestMessage {
+    const message = createBaseChallengeRequestMessage();
+    message.address = object.address ?? "";
+    return message;
+  }
+}
+
+function createBaseSignedChallengeMessage(): SignedChallengeMessage {
+  return { authChainJson: "" };
+}
+
+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);
+    }
+    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();
+    }
+    if (message.desiredRoom !== undefined) {
+      writer.uint32(18).string(message.desiredRoom);
+    }
+    return writer;
+  }
+
+  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 = createBaseHeartbeat();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.position = Position.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.desiredRoom = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Heartbeat {
+    return {
+      position: isSet(object.position) ? Position.fromJSON(object.position) : undefined,
+      desiredRoom: isSet(object.desiredRoom) ? String(object.desiredRoom) : undefined,
+    };
+  }
+
+  export function toJSON(message: Heartbeat): unknown {
+    const obj: any = {};
+    message.position !== undefined && (obj.position = message.position ? Position.toJSON(message.position) : undefined);
+    message.desiredRoom !== undefined && (obj.desiredRoom = message.desiredRoom);
+    return obj;
+  }
+
+  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 createBaseClientPacket(): ClientPacket {
+  return { message: undefined };
+}
+
+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;
+    }
+    return writer;
+  }
+
+  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 = createBaseClientPacket();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = {
+            $case: "challengeRequest",
+            challengeRequest: ChallengeRequestMessage.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.message = {
+            $case: "signedChallenge",
+            signedChallenge: SignedChallengeMessage.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            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;
+  }
+
+  export function fromJSON(object: any): ClientPacket {
+    return {
+      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,
+    };
+  }
+
+  export function toJSON(message: ClientPacket): unknown {
+    const obj: any = {};
+    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;
+  }
+
+  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 createBaseIslandData(): IslandData {
+  return { id: "", peers: [], maxPeers: 0, center: undefined, radius: 0 };
+}
+
+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.center !== undefined) {
+      Position.encode(message.center, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.radius !== 0) {
+      writer.uint32(41).double(message.radius);
+    }
+    return writer;
+  }
+
+  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 = createBaseIslandData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.id = reader.string();
+          continue;
+        case 2:
+          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;
+  }
+
+  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,
+    };
+  }
+
+  export function toJSON(message: IslandData): 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 ? Position.toJSON(message.center) : undefined);
+    message.radius !== undefined && (obj.radius = message.radius);
+    return obj;
+  }
+
+  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 createBaseIslandStatusMessage(): IslandStatusMessage {
+  return { data: [] };
+}
+
+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 = [];
+    }
+    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.commitHash !== undefined) {
+      writer.uint32(18).string(message.commitHash);
+    }
+    if (message.userCount !== 0) {
+      writer.uint32(24).uint32(message.userCount);
+    }
+    return writer;
+  }
+
+  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 = createBaseServiceStatus();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.currentTime = longToNumber(reader.uint64() as Long);
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.commitHash = reader.string();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.userCount = reader.uint32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ServiceStatus {
+    return {
+      currentTime: isSet(object.currentTime) ? Number(object.currentTime) : 0,
+      commitHash: isSet(object.commitHash) ? String(object.commitHash) : undefined,
+      userCount: isSet(object.userCount) ? Number(object.userCount) : 0,
+    };
+  }
+
+  export function toJSON(message: ServiceStatus): unknown {
+    const obj: any = {};
+    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;
+  }
+
+  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 (message.status !== undefined) {
+      ServiceStatus.encode(message.status, writer.uint32(18).fork()).ldelim();
+    }
+    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;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+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;
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}