@dcl/protocol 1.0.0-3244256590.commit-612d716 → 1.0.0-3244293554.commit-269b186

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

@@ -66,36 +66,15 @@ export interface WsKicked {
 }
 
 export interface WsPacket {
-  /** direction: server->client */
-  welcomeMessage:
-    | WsWelcome
-    | undefined;
-  /** direction: server->client */
-  peerJoinMessage:
-    | WsPeerJoin
-    | undefined;
-  /** direction: client->(server)->client */
-  peerUpdateMessage:
-    | WsPeerUpdate
-    | undefined;
-  /** direction: server->client */
-  challengeMessage:
-    | WsChallengeRequired
-    | undefined;
-  /** direction: client->server */
-  signedChallengeForServer:
-    | WsSignedChallenge
-    | undefined;
-  /** direction: server->client */
-  peerLeaveMessage:
-    | WsPeerLeave
-    | undefined;
-  /** direction: client->server */
-  peerIdentification:
-    | WsIdentification
-    | undefined;
-  /** direction: server->client */
-  peerKicked: WsKicked | undefined;
+  message?:
+    | { $case: "welcomeMessage"; welcomeMessage: WsWelcome }
+    | { $case: "peerJoinMessage"; peerJoinMessage: WsPeerJoin }
+    | { $case: "peerUpdateMessage"; peerUpdateMessage: WsPeerUpdate }
+    | { $case: "challengeMessage"; challengeMessage: WsChallengeRequired }
+    | { $case: "signedChallengeForServer"; signedChallengeForServer: WsSignedChallenge }
+    | { $case: "peerLeaveMessage"; peerLeaveMessage: WsPeerLeave }
+    | { $case: "peerIdentification"; peerIdentification: WsIdentification }
+    | { $case: "peerKicked"; peerKicked: WsKicked };
 }
 
 function createBaseWsWelcome(): WsWelcome {
@@ -599,43 +578,34 @@ export const WsKicked = {
 };
 
 function createBaseWsPacket(): WsPacket {
-  return {
-    welcomeMessage: undefined,
-    peerJoinMessage: undefined,
-    peerUpdateMessage: undefined,
-    challengeMessage: undefined,
-    signedChallengeForServer: undefined,
-    peerLeaveMessage: undefined,
-    peerIdentification: undefined,
-    peerKicked: undefined,
-  };
+  return { message: undefined };
 }
 
 export const WsPacket = {
   encode(message: WsPacket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.welcomeMessage !== undefined) {
-      WsWelcome.encode(message.welcomeMessage, writer.uint32(10).fork()).ldelim();
+    if (message.message?.$case === "welcomeMessage") {
+      WsWelcome.encode(message.message.welcomeMessage, writer.uint32(10).fork()).ldelim();
     }
-    if (message.peerJoinMessage !== undefined) {
-      WsPeerJoin.encode(message.peerJoinMessage, writer.uint32(18).fork()).ldelim();
+    if (message.message?.$case === "peerJoinMessage") {
+      WsPeerJoin.encode(message.message.peerJoinMessage, writer.uint32(18).fork()).ldelim();
     }
-    if (message.peerUpdateMessage !== undefined) {
-      WsPeerUpdate.encode(message.peerUpdateMessage, writer.uint32(26).fork()).ldelim();
+    if (message.message?.$case === "peerUpdateMessage") {
+      WsPeerUpdate.encode(message.message.peerUpdateMessage, writer.uint32(26).fork()).ldelim();
     }
-    if (message.challengeMessage !== undefined) {
-      WsChallengeRequired.encode(message.challengeMessage, writer.uint32(34).fork()).ldelim();
+    if (message.message?.$case === "challengeMessage") {
+      WsChallengeRequired.encode(message.message.challengeMessage, writer.uint32(34).fork()).ldelim();
     }
-    if (message.signedChallengeForServer !== undefined) {
-      WsSignedChallenge.encode(message.signedChallengeForServer, writer.uint32(42).fork()).ldelim();
+    if (message.message?.$case === "signedChallengeForServer") {
+      WsSignedChallenge.encode(message.message.signedChallengeForServer, writer.uint32(42).fork()).ldelim();
     }
-    if (message.peerLeaveMessage !== undefined) {
-      WsPeerLeave.encode(message.peerLeaveMessage, writer.uint32(50).fork()).ldelim();
+    if (message.message?.$case === "peerLeaveMessage") {
+      WsPeerLeave.encode(message.message.peerLeaveMessage, writer.uint32(50).fork()).ldelim();
     }
-    if (message.peerIdentification !== undefined) {
-      WsIdentification.encode(message.peerIdentification, writer.uint32(58).fork()).ldelim();
+    if (message.message?.$case === "peerIdentification") {
+      WsIdentification.encode(message.message.peerIdentification, writer.uint32(58).fork()).ldelim();
     }
-    if (message.peerKicked !== undefined) {
-      WsKicked.encode(message.peerKicked, writer.uint32(66).fork()).ldelim();
+    if (message.message?.$case === "peerKicked") {
+      WsKicked.encode(message.message.peerKicked, writer.uint32(66).fork()).ldelim();
     }
     return writer;
   },
@@ -648,28 +618,43 @@ export const WsPacket = {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.welcomeMessage = WsWelcome.decode(reader, reader.uint32());
+          message.message = { $case: "welcomeMessage", welcomeMessage: WsWelcome.decode(reader, reader.uint32()) };
           break;
         case 2:
-          message.peerJoinMessage = WsPeerJoin.decode(reader, reader.uint32());
+          message.message = { $case: "peerJoinMessage", peerJoinMessage: WsPeerJoin.decode(reader, reader.uint32()) };
           break;
         case 3:
-          message.peerUpdateMessage = WsPeerUpdate.decode(reader, reader.uint32());
+          message.message = {
+            $case: "peerUpdateMessage",
+            peerUpdateMessage: WsPeerUpdate.decode(reader, reader.uint32()),
+          };
           break;
         case 4:
-          message.challengeMessage = WsChallengeRequired.decode(reader, reader.uint32());
+          message.message = {
+            $case: "challengeMessage",
+            challengeMessage: WsChallengeRequired.decode(reader, reader.uint32()),
+          };
           break;
         case 5:
-          message.signedChallengeForServer = WsSignedChallenge.decode(reader, reader.uint32());
+          message.message = {
+            $case: "signedChallengeForServer",
+            signedChallengeForServer: WsSignedChallenge.decode(reader, reader.uint32()),
+          };
           break;
         case 6:
-          message.peerLeaveMessage = WsPeerLeave.decode(reader, reader.uint32());
+          message.message = {
+            $case: "peerLeaveMessage",
+            peerLeaveMessage: WsPeerLeave.decode(reader, reader.uint32()),
+          };
           break;
         case 7:
-          message.peerIdentification = WsIdentification.decode(reader, reader.uint32());
+          message.message = {
+            $case: "peerIdentification",
+            peerIdentification: WsIdentification.decode(reader, reader.uint32()),
+          };
           break;
         case 8:
-          message.peerKicked = WsKicked.decode(reader, reader.uint32());
+          message.message = { $case: "peerKicked", peerKicked: WsKicked.decode(reader, reader.uint32()) };
           break;
         default:
           reader.skipType(tag & 7);
@@ -681,74 +666,137 @@ export const WsPacket = {
 
   fromJSON(object: any): WsPacket {
     return {
-      welcomeMessage: isSet(object.welcomeMessage) ? WsWelcome.fromJSON(object.welcomeMessage) : undefined,
-      peerJoinMessage: isSet(object.peerJoinMessage) ? WsPeerJoin.fromJSON(object.peerJoinMessage) : undefined,
-      peerUpdateMessage: isSet(object.peerUpdateMessage) ? WsPeerUpdate.fromJSON(object.peerUpdateMessage) : undefined,
-      challengeMessage: isSet(object.challengeMessage)
-        ? WsChallengeRequired.fromJSON(object.challengeMessage)
-        : undefined,
-      signedChallengeForServer: isSet(object.signedChallengeForServer)
-        ? WsSignedChallenge.fromJSON(object.signedChallengeForServer)
-        : undefined,
-      peerLeaveMessage: isSet(object.peerLeaveMessage) ? WsPeerLeave.fromJSON(object.peerLeaveMessage) : undefined,
-      peerIdentification: isSet(object.peerIdentification)
-        ? WsIdentification.fromJSON(object.peerIdentification)
+      message: isSet(object.welcomeMessage)
+        ? { $case: "welcomeMessage", welcomeMessage: WsWelcome.fromJSON(object.welcomeMessage) }
+        : isSet(object.peerJoinMessage)
+        ? { $case: "peerJoinMessage", peerJoinMessage: WsPeerJoin.fromJSON(object.peerJoinMessage) }
+        : isSet(object.peerUpdateMessage)
+        ? { $case: "peerUpdateMessage", peerUpdateMessage: WsPeerUpdate.fromJSON(object.peerUpdateMessage) }
+        : isSet(object.challengeMessage)
+        ? { $case: "challengeMessage", challengeMessage: WsChallengeRequired.fromJSON(object.challengeMessage) }
+        : isSet(object.signedChallengeForServer)
+        ? {
+          $case: "signedChallengeForServer",
+          signedChallengeForServer: WsSignedChallenge.fromJSON(object.signedChallengeForServer),
+        }
+        : isSet(object.peerLeaveMessage)
+        ? { $case: "peerLeaveMessage", peerLeaveMessage: WsPeerLeave.fromJSON(object.peerLeaveMessage) }
+        : isSet(object.peerIdentification)
+        ? { $case: "peerIdentification", peerIdentification: WsIdentification.fromJSON(object.peerIdentification) }
+        : isSet(object.peerKicked)
+        ? { $case: "peerKicked", peerKicked: WsKicked.fromJSON(object.peerKicked) }
         : undefined,
-      peerKicked: isSet(object.peerKicked) ? WsKicked.fromJSON(object.peerKicked) : undefined,
     };
   },
 
   toJSON(message: WsPacket): unknown {
     const obj: any = {};
-    message.welcomeMessage !== undefined &&
-      (obj.welcomeMessage = message.welcomeMessage ? WsWelcome.toJSON(message.welcomeMessage) : undefined);
-    message.peerJoinMessage !== undefined &&
-      (obj.peerJoinMessage = message.peerJoinMessage ? WsPeerJoin.toJSON(message.peerJoinMessage) : undefined);
-    message.peerUpdateMessage !== undefined &&
-      (obj.peerUpdateMessage = message.peerUpdateMessage ? WsPeerUpdate.toJSON(message.peerUpdateMessage) : undefined);
-    message.challengeMessage !== undefined && (obj.challengeMessage = message.challengeMessage
-      ? WsChallengeRequired.toJSON(message.challengeMessage)
+    message.message?.$case === "welcomeMessage" && (obj.welcomeMessage = message.message?.welcomeMessage
+      ? WsWelcome.toJSON(message.message?.welcomeMessage)
+      : undefined);
+    message.message?.$case === "peerJoinMessage" && (obj.peerJoinMessage = message.message?.peerJoinMessage
+      ? WsPeerJoin.toJSON(message.message?.peerJoinMessage)
       : undefined);
-    message.signedChallengeForServer !== undefined && (obj.signedChallengeForServer = message.signedChallengeForServer
-      ? WsSignedChallenge.toJSON(message.signedChallengeForServer)
+    message.message?.$case === "peerUpdateMessage" && (obj.peerUpdateMessage = message.message?.peerUpdateMessage
+      ? WsPeerUpdate.toJSON(message.message?.peerUpdateMessage)
       : undefined);
-    message.peerLeaveMessage !== undefined &&
-      (obj.peerLeaveMessage = message.peerLeaveMessage ? WsPeerLeave.toJSON(message.peerLeaveMessage) : undefined);
-    message.peerIdentification !== undefined && (obj.peerIdentification = message.peerIdentification
-      ? WsIdentification.toJSON(message.peerIdentification)
+    message.message?.$case === "challengeMessage" && (obj.challengeMessage = message.message?.challengeMessage
+      ? WsChallengeRequired.toJSON(message.message?.challengeMessage)
       : undefined);
-    message.peerKicked !== undefined &&
-      (obj.peerKicked = message.peerKicked ? WsKicked.toJSON(message.peerKicked) : undefined);
+    message.message?.$case === "signedChallengeForServer" &&
+      (obj.signedChallengeForServer = message.message?.signedChallengeForServer
+        ? WsSignedChallenge.toJSON(message.message?.signedChallengeForServer)
+        : undefined);
+    message.message?.$case === "peerLeaveMessage" && (obj.peerLeaveMessage = message.message?.peerLeaveMessage
+      ? WsPeerLeave.toJSON(message.message?.peerLeaveMessage)
+      : undefined);
+    message.message?.$case === "peerIdentification" && (obj.peerIdentification = message.message?.peerIdentification
+      ? WsIdentification.toJSON(message.message?.peerIdentification)
+      : undefined);
+    message.message?.$case === "peerKicked" &&
+      (obj.peerKicked = message.message?.peerKicked ? WsKicked.toJSON(message.message?.peerKicked) : undefined);
     return obj;
   },
 
   fromPartial<I extends Exact<DeepPartial<WsPacket>, I>>(object: I): WsPacket {
     const message = createBaseWsPacket();
-    message.welcomeMessage = (object.welcomeMessage !== undefined && object.welcomeMessage !== null)
-      ? WsWelcome.fromPartial(object.welcomeMessage)
-      : undefined;
-    message.peerJoinMessage = (object.peerJoinMessage !== undefined && object.peerJoinMessage !== null)
-      ? WsPeerJoin.fromPartial(object.peerJoinMessage)
-      : undefined;
-    message.peerUpdateMessage = (object.peerUpdateMessage !== undefined && object.peerUpdateMessage !== null)
-      ? WsPeerUpdate.fromPartial(object.peerUpdateMessage)
-      : undefined;
-    message.challengeMessage = (object.challengeMessage !== undefined && object.challengeMessage !== null)
-      ? WsChallengeRequired.fromPartial(object.challengeMessage)
-      : undefined;
-    message.signedChallengeForServer =
-      (object.signedChallengeForServer !== undefined && object.signedChallengeForServer !== null)
-        ? WsSignedChallenge.fromPartial(object.signedChallengeForServer)
-        : undefined;
-    message.peerLeaveMessage = (object.peerLeaveMessage !== undefined && object.peerLeaveMessage !== null)
-      ? WsPeerLeave.fromPartial(object.peerLeaveMessage)
-      : undefined;
-    message.peerIdentification = (object.peerIdentification !== undefined && object.peerIdentification !== null)
-      ? WsIdentification.fromPartial(object.peerIdentification)
-      : undefined;
-    message.peerKicked = (object.peerKicked !== undefined && object.peerKicked !== null)
-      ? WsKicked.fromPartial(object.peerKicked)
-      : undefined;
+    if (
+      object.message?.$case === "welcomeMessage" &&
+      object.message?.welcomeMessage !== undefined &&
+      object.message?.welcomeMessage !== null
+    ) {
+      message.message = {
+        $case: "welcomeMessage",
+        welcomeMessage: WsWelcome.fromPartial(object.message.welcomeMessage),
+      };
+    }
+    if (
+      object.message?.$case === "peerJoinMessage" &&
+      object.message?.peerJoinMessage !== undefined &&
+      object.message?.peerJoinMessage !== null
+    ) {
+      message.message = {
+        $case: "peerJoinMessage",
+        peerJoinMessage: WsPeerJoin.fromPartial(object.message.peerJoinMessage),
+      };
+    }
+    if (
+      object.message?.$case === "peerUpdateMessage" &&
+      object.message?.peerUpdateMessage !== undefined &&
+      object.message?.peerUpdateMessage !== null
+    ) {
+      message.message = {
+        $case: "peerUpdateMessage",
+        peerUpdateMessage: WsPeerUpdate.fromPartial(object.message.peerUpdateMessage),
+      };
+    }
+    if (
+      object.message?.$case === "challengeMessage" &&
+      object.message?.challengeMessage !== undefined &&
+      object.message?.challengeMessage !== null
+    ) {
+      message.message = {
+        $case: "challengeMessage",
+        challengeMessage: WsChallengeRequired.fromPartial(object.message.challengeMessage),
+      };
+    }
+    if (
+      object.message?.$case === "signedChallengeForServer" &&
+      object.message?.signedChallengeForServer !== undefined &&
+      object.message?.signedChallengeForServer !== null
+    ) {
+      message.message = {
+        $case: "signedChallengeForServer",
+        signedChallengeForServer: WsSignedChallenge.fromPartial(object.message.signedChallengeForServer),
+      };
+    }
+    if (
+      object.message?.$case === "peerLeaveMessage" &&
+      object.message?.peerLeaveMessage !== undefined &&
+      object.message?.peerLeaveMessage !== null
+    ) {
+      message.message = {
+        $case: "peerLeaveMessage",
+        peerLeaveMessage: WsPeerLeave.fromPartial(object.message.peerLeaveMessage),
+      };
+    }
+    if (
+      object.message?.$case === "peerIdentification" &&
+      object.message?.peerIdentification !== undefined &&
+      object.message?.peerIdentification !== null
+    ) {
+      message.message = {
+        $case: "peerIdentification",
+        peerIdentification: WsIdentification.fromPartial(object.message.peerIdentification),
+      };
+    }
+    if (
+      object.message?.$case === "peerKicked" &&
+      object.message?.peerKicked !== undefined &&
+      object.message?.peerKicked !== null
+    ) {
+      message.message = { $case: "peerKicked", peerKicked: WsKicked.fromPartial(object.message.peerKicked) };
+    }
     return message;
   },
 };
@@ -801,6 +849,7 @@ type Builtin = Date | Function | Uint8Array | string | number | boolean | undefi
 
 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>;
 

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

@@ -103,10 +103,10 @@ export interface TransportAuthorizationResponse_ConnStrsEntry {
 }
 
 export interface TransportMessage {
-  init: TransportInit | undefined;
-  heartbeat: TransportHeartbeat | undefined;
-  authRequest: TransportAuthorizationRequest | undefined;
-  authResponse: TransportAuthorizationResponse | undefined;
+  message?: { $case: "init"; init: TransportInit } | { $case: "heartbeat"; heartbeat: TransportHeartbeat } | {
+    $case: "authRequest";
+    authRequest: TransportAuthorizationRequest;
+  } | { $case: "authResponse"; authResponse: TransportAuthorizationResponse };
 }
 
 function createBasePosition3DMessage(): Position3DMessage {
@@ -920,22 +920,22 @@ export const TransportAuthorizationResponse_ConnStrsEntry = {
 };
 
 function createBaseTransportMessage(): TransportMessage {
-  return { init: undefined, heartbeat: undefined, authRequest: undefined, authResponse: undefined };
+  return { message: undefined };
 }
 
 export const TransportMessage = {
   encode(message: TransportMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.init !== undefined) {
-      TransportInit.encode(message.init, writer.uint32(10).fork()).ldelim();
+    if (message.message?.$case === "init") {
+      TransportInit.encode(message.message.init, writer.uint32(10).fork()).ldelim();
     }
-    if (message.heartbeat !== undefined) {
-      TransportHeartbeat.encode(message.heartbeat, writer.uint32(18).fork()).ldelim();
+    if (message.message?.$case === "heartbeat") {
+      TransportHeartbeat.encode(message.message.heartbeat, writer.uint32(18).fork()).ldelim();
     }
-    if (message.authRequest !== undefined) {
-      TransportAuthorizationRequest.encode(message.authRequest, writer.uint32(26).fork()).ldelim();
+    if (message.message?.$case === "authRequest") {
+      TransportAuthorizationRequest.encode(message.message.authRequest, writer.uint32(26).fork()).ldelim();
     }
-    if (message.authResponse !== undefined) {
-      TransportAuthorizationResponse.encode(message.authResponse, writer.uint32(34).fork()).ldelim();
+    if (message.message?.$case === "authResponse") {
+      TransportAuthorizationResponse.encode(message.message.authResponse, writer.uint32(34).fork()).ldelim();
     }
     return writer;
   },
@@ -948,16 +948,22 @@ export const TransportMessage = {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.init = TransportInit.decode(reader, reader.uint32());
+          message.message = { $case: "init", init: TransportInit.decode(reader, reader.uint32()) };
           break;
         case 2:
-          message.heartbeat = TransportHeartbeat.decode(reader, reader.uint32());
+          message.message = { $case: "heartbeat", heartbeat: TransportHeartbeat.decode(reader, reader.uint32()) };
           break;
         case 3:
-          message.authRequest = TransportAuthorizationRequest.decode(reader, reader.uint32());
+          message.message = {
+            $case: "authRequest",
+            authRequest: TransportAuthorizationRequest.decode(reader, reader.uint32()),
+          };
           break;
         case 4:
-          message.authResponse = TransportAuthorizationResponse.decode(reader, reader.uint32());
+          message.message = {
+            $case: "authResponse",
+            authResponse: TransportAuthorizationResponse.decode(reader, reader.uint32()),
+          };
           break;
         default:
           reader.skipType(tag & 7);
@@ -969,43 +975,65 @@ export const TransportMessage = {
 
   fromJSON(object: any): TransportMessage {
     return {
-      init: isSet(object.init) ? TransportInit.fromJSON(object.init) : undefined,
-      heartbeat: isSet(object.heartbeat) ? TransportHeartbeat.fromJSON(object.heartbeat) : undefined,
-      authRequest: isSet(object.authRequest) ? TransportAuthorizationRequest.fromJSON(object.authRequest) : undefined,
-      authResponse: isSet(object.authResponse)
-        ? TransportAuthorizationResponse.fromJSON(object.authResponse)
+      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,
     };
   },
 
   toJSON(message: TransportMessage): unknown {
     const obj: any = {};
-    message.init !== undefined && (obj.init = message.init ? TransportInit.toJSON(message.init) : undefined);
-    message.heartbeat !== undefined &&
-      (obj.heartbeat = message.heartbeat ? TransportHeartbeat.toJSON(message.heartbeat) : undefined);
-    message.authRequest !== undefined &&
-      (obj.authRequest = message.authRequest ? TransportAuthorizationRequest.toJSON(message.authRequest) : undefined);
-    message.authResponse !== undefined &&
-      (obj.authResponse = message.authResponse
-        ? TransportAuthorizationResponse.toJSON(message.authResponse)
-        : undefined);
+    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);
     return obj;
   },
 
   fromPartial<I extends Exact<DeepPartial<TransportMessage>, I>>(object: I): TransportMessage {
     const message = createBaseTransportMessage();
-    message.init = (object.init !== undefined && object.init !== null)
-      ? TransportInit.fromPartial(object.init)
-      : undefined;
-    message.heartbeat = (object.heartbeat !== undefined && object.heartbeat !== null)
-      ? TransportHeartbeat.fromPartial(object.heartbeat)
-      : undefined;
-    message.authRequest = (object.authRequest !== undefined && object.authRequest !== null)
-      ? TransportAuthorizationRequest.fromPartial(object.authRequest)
-      : undefined;
-    message.authResponse = (object.authResponse !== undefined && object.authResponse !== null)
-      ? TransportAuthorizationResponse.fromPartial(object.authResponse)
-      : undefined;
+    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) };
+    }
+    if (
+      object.message?.$case === "authRequest" &&
+      object.message?.authRequest !== undefined &&
+      object.message?.authRequest !== null
+    ) {
+      message.message = {
+        $case: "authRequest",
+        authRequest: TransportAuthorizationRequest.fromPartial(object.message.authRequest),
+      };
+    }
+    if (
+      object.message?.$case === "authResponse" &&
+      object.message?.authResponse !== undefined &&
+      object.message?.authResponse !== null
+    ) {
+      message.message = {
+        $case: "authResponse",
+        authResponse: TransportAuthorizationResponse.fromPartial(object.message.authResponse),
+      };
+    }
     return message;
   },
 };
@@ -1014,6 +1042,7 @@ type Builtin = Date | Function | Uint8Array | string | number | boolean | undefi
 
 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>;