@dcl/protocol 1.0.0-2569677750.commit-6ce832a → 1.0.0-25751414897.commit-a9f7d81

package/out-ts/decentraland/kernel/comms/rfc4/comms.gen.ts

@@ -0,0 +1,1849 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.kernel.comms.rfc4";
+
+export interface Packet {
+  message?:
+    | { $case: "position"; position: Position }
+    | { $case: "profileVersion"; profileVersion: AnnounceProfileVersion }
+    | { $case: "profileRequest"; profileRequest: ProfileRequest }
+    | { $case: "profileResponse"; profileResponse: ProfileResponse }
+    | { $case: "chat"; chat: Chat }
+    | { $case: "scene"; scene: Scene }
+    | { $case: "voice"; voice: Voice }
+    | { $case: "movement"; movement: Movement }
+    | { $case: "playerEmote"; playerEmote: PlayerEmote }
+    | { $case: "sceneEmote"; sceneEmote: SceneEmote }
+    | { $case: "movementCompressed"; movementCompressed: MovementCompressed }
+    | undefined;
+  protocolVersion: number;
+}
+
+export interface Position {
+  /** command number */
+  index: number;
+  /** world position */
+  positionX: number;
+  positionY: number;
+  positionZ: number;
+  /** quaternion */
+  rotationX: number;
+  rotationY: number;
+  rotationZ: number;
+  rotationW: number;
+}
+
+export interface Movement {
+  /** command number */
+  timestamp: number;
+  /** world position */
+  positionX: number;
+  positionY: number;
+  positionZ: number;
+  /** velocity */
+  velocityX: number;
+  velocityY: number;
+  velocityZ: number;
+  /** animations */
+  movementBlendValue: number;
+  slideBlendValue: number;
+  isGrounded: boolean;
+  /** deprecated */
+  isJumping: boolean;
+  jumpCount: number;
+  isLongJump: boolean;
+  isLongFall: boolean;
+  isFalling: boolean;
+  isStunned: boolean;
+  glideState: Movement_GlideState;
+  rotationY: number;
+  /** interpolation */
+  isInstant: boolean;
+  isEmoting: boolean;
+  /** head-sync (enabled flags + world-space yaw and pitch angles, in degrees) */
+  headIkYawEnabled: boolean;
+  headIkPitchEnabled: boolean;
+  headYaw: number;
+  headPitch: number;
+  /** point-at */
+  pointAtX: number;
+  pointAtY: number;
+  pointAtZ: number;
+  isPointingAt: boolean;
+}
+
+export enum Movement_GlideState {
+  PROP_CLOSED = 0,
+  OPENING_PROP = 1,
+  GLIDING = 2,
+  CLOSING_PROP = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function movement_GlideStateFromJSON(object: any): Movement_GlideState {
+  switch (object) {
+    case 0:
+    case "PROP_CLOSED":
+      return Movement_GlideState.PROP_CLOSED;
+    case 1:
+    case "OPENING_PROP":
+      return Movement_GlideState.OPENING_PROP;
+    case 2:
+    case "GLIDING":
+      return Movement_GlideState.GLIDING;
+    case 3:
+    case "CLOSING_PROP":
+      return Movement_GlideState.CLOSING_PROP;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return Movement_GlideState.UNRECOGNIZED;
+  }
+}
+
+export function movement_GlideStateToJSON(object: Movement_GlideState): string {
+  switch (object) {
+    case Movement_GlideState.PROP_CLOSED:
+      return "PROP_CLOSED";
+    case Movement_GlideState.OPENING_PROP:
+      return "OPENING_PROP";
+    case Movement_GlideState.GLIDING:
+      return "GLIDING";
+    case Movement_GlideState.CLOSING_PROP:
+      return "CLOSING_PROP";
+    case Movement_GlideState.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface MovementCompressed {
+  /** bit-compressed: timestamp + animations */
+  temporalData: number;
+  /** bit-compressed: position + velocity */
+  movementData: number;
+  /** bit-compressed: enabled flags + yaw + pitch */
+  headSyncData: number;
+  /** bit-compressed: flag + point coordinates */
+  pointAtData: number;
+}
+
+export interface PlayerEmote {
+  incrementalId: number;
+  urn: string;
+  timestamp: number;
+}
+
+export interface SceneEmote {
+  sceneEntityId: string;
+  source: string;
+}
+
+export interface AnnounceProfileVersion {
+  profileVersion: number;
+}
+
+export interface ProfileRequest {
+  address: string;
+  profileVersion: number;
+}
+
+export interface ProfileResponse {
+  serializedProfile: string;
+  baseUrl: string;
+}
+
+export interface Chat {
+  message: string;
+  timestamp: number;
+}
+
+export interface Scene {
+  sceneId: string;
+  data: Uint8Array;
+}
+
+export interface Voice {
+  encodedSamples: Uint8Array;
+  index: number;
+  codec: Voice_VoiceCodec;
+}
+
+export enum Voice_VoiceCodec {
+  VC_OPUS = 0,
+  UNRECOGNIZED = -1,
+}
+
+export function voice_VoiceCodecFromJSON(object: any): Voice_VoiceCodec {
+  switch (object) {
+    case 0:
+    case "VC_OPUS":
+      return Voice_VoiceCodec.VC_OPUS;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return Voice_VoiceCodec.UNRECOGNIZED;
+  }
+}
+
+export function voice_VoiceCodecToJSON(object: Voice_VoiceCodec): string {
+  switch (object) {
+    case Voice_VoiceCodec.VC_OPUS:
+      return "VC_OPUS";
+    case Voice_VoiceCodec.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+function createBasePacket(): Packet {
+  return { message: undefined, protocolVersion: 0 };
+}
+
+export namespace Packet {
+  export function encode(message: Packet, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.message?.$case) {
+      case "position":
+        Position.encode(message.message.position, writer.uint32(10).fork()).ldelim();
+        break;
+      case "profileVersion":
+        AnnounceProfileVersion.encode(message.message.profileVersion, writer.uint32(18).fork()).ldelim();
+        break;
+      case "profileRequest":
+        ProfileRequest.encode(message.message.profileRequest, writer.uint32(26).fork()).ldelim();
+        break;
+      case "profileResponse":
+        ProfileResponse.encode(message.message.profileResponse, writer.uint32(34).fork()).ldelim();
+        break;
+      case "chat":
+        Chat.encode(message.message.chat, writer.uint32(42).fork()).ldelim();
+        break;
+      case "scene":
+        Scene.encode(message.message.scene, writer.uint32(50).fork()).ldelim();
+        break;
+      case "voice":
+        Voice.encode(message.message.voice, writer.uint32(58).fork()).ldelim();
+        break;
+      case "movement":
+        Movement.encode(message.message.movement, writer.uint32(66).fork()).ldelim();
+        break;
+      case "playerEmote":
+        PlayerEmote.encode(message.message.playerEmote, writer.uint32(74).fork()).ldelim();
+        break;
+      case "sceneEmote":
+        SceneEmote.encode(message.message.sceneEmote, writer.uint32(82).fork()).ldelim();
+        break;
+      case "movementCompressed":
+        MovementCompressed.encode(message.message.movementCompressed, writer.uint32(98).fork()).ldelim();
+        break;
+    }
+    if (message.protocolVersion !== 0) {
+      writer.uint32(88).uint32(message.protocolVersion);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Packet {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePacket();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = { $case: "position", position: Position.decode(reader, reader.uint32()) };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.message = {
+            $case: "profileVersion",
+            profileVersion: AnnounceProfileVersion.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.message = { $case: "profileRequest", profileRequest: ProfileRequest.decode(reader, reader.uint32()) };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.message = {
+            $case: "profileResponse",
+            profileResponse: ProfileResponse.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.message = { $case: "chat", chat: Chat.decode(reader, reader.uint32()) };
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.message = { $case: "scene", scene: Scene.decode(reader, reader.uint32()) };
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+
+          message.message = { $case: "voice", voice: Voice.decode(reader, reader.uint32()) };
+          continue;
+        case 8:
+          if (tag !== 66) {
+            break;
+          }
+
+          message.message = { $case: "movement", movement: Movement.decode(reader, reader.uint32()) };
+          continue;
+        case 9:
+          if (tag !== 74) {
+            break;
+          }
+
+          message.message = { $case: "playerEmote", playerEmote: PlayerEmote.decode(reader, reader.uint32()) };
+          continue;
+        case 10:
+          if (tag !== 82) {
+            break;
+          }
+
+          message.message = { $case: "sceneEmote", sceneEmote: SceneEmote.decode(reader, reader.uint32()) };
+          continue;
+        case 12:
+          if (tag !== 98) {
+            break;
+          }
+
+          message.message = {
+            $case: "movementCompressed",
+            movementCompressed: MovementCompressed.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 11:
+          if (tag !== 88) {
+            break;
+          }
+
+          message.protocolVersion = reader.uint32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Packet {
+    return {
+      message: isSet(object.position)
+        ? { $case: "position", position: Position.fromJSON(object.position) }
+        : isSet(object.profileVersion)
+        ? { $case: "profileVersion", profileVersion: AnnounceProfileVersion.fromJSON(object.profileVersion) }
+        : isSet(object.profileRequest)
+        ? { $case: "profileRequest", profileRequest: ProfileRequest.fromJSON(object.profileRequest) }
+        : isSet(object.profileResponse)
+        ? { $case: "profileResponse", profileResponse: ProfileResponse.fromJSON(object.profileResponse) }
+        : isSet(object.chat)
+        ? { $case: "chat", chat: Chat.fromJSON(object.chat) }
+        : isSet(object.scene)
+        ? { $case: "scene", scene: Scene.fromJSON(object.scene) }
+        : isSet(object.voice)
+        ? { $case: "voice", voice: Voice.fromJSON(object.voice) }
+        : isSet(object.movement)
+        ? { $case: "movement", movement: Movement.fromJSON(object.movement) }
+        : isSet(object.playerEmote)
+        ? { $case: "playerEmote", playerEmote: PlayerEmote.fromJSON(object.playerEmote) }
+        : isSet(object.sceneEmote)
+        ? { $case: "sceneEmote", sceneEmote: SceneEmote.fromJSON(object.sceneEmote) }
+        : isSet(object.movementCompressed)
+        ? { $case: "movementCompressed", movementCompressed: MovementCompressed.fromJSON(object.movementCompressed) }
+        : undefined,
+      protocolVersion: isSet(object.protocolVersion) ? Number(object.protocolVersion) : 0,
+    };
+  }
+
+  export function toJSON(message: Packet): unknown {
+    const obj: any = {};
+    message.message?.$case === "position" &&
+      (obj.position = message.message?.position ? Position.toJSON(message.message?.position) : undefined);
+    message.message?.$case === "profileVersion" &&
+      (obj.profileVersion = message.message?.profileVersion
+        ? AnnounceProfileVersion.toJSON(message.message?.profileVersion)
+        : undefined);
+    message.message?.$case === "profileRequest" &&
+      (obj.profileRequest = message.message?.profileRequest
+        ? ProfileRequest.toJSON(message.message?.profileRequest)
+        : undefined);
+    message.message?.$case === "profileResponse" &&
+      (obj.profileResponse = message.message?.profileResponse
+        ? ProfileResponse.toJSON(message.message?.profileResponse)
+        : undefined);
+    message.message?.$case === "chat" &&
+      (obj.chat = message.message?.chat ? Chat.toJSON(message.message?.chat) : undefined);
+    message.message?.$case === "scene" &&
+      (obj.scene = message.message?.scene ? Scene.toJSON(message.message?.scene) : undefined);
+    message.message?.$case === "voice" &&
+      (obj.voice = message.message?.voice ? Voice.toJSON(message.message?.voice) : undefined);
+    message.message?.$case === "movement" &&
+      (obj.movement = message.message?.movement ? Movement.toJSON(message.message?.movement) : undefined);
+    message.message?.$case === "playerEmote" &&
+      (obj.playerEmote = message.message?.playerEmote ? PlayerEmote.toJSON(message.message?.playerEmote) : undefined);
+    message.message?.$case === "sceneEmote" &&
+      (obj.sceneEmote = message.message?.sceneEmote ? SceneEmote.toJSON(message.message?.sceneEmote) : undefined);
+    message.message?.$case === "movementCompressed" &&
+      (obj.movementCompressed = message.message?.movementCompressed
+        ? MovementCompressed.toJSON(message.message?.movementCompressed)
+        : undefined);
+    message.protocolVersion !== undefined && (obj.protocolVersion = Math.round(message.protocolVersion));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Packet>, I>>(base?: I): Packet {
+    return Packet.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Packet>, I>>(object: I): Packet {
+    const message = createBasePacket();
+    if (
+      object.message?.$case === "position" &&
+      object.message?.position !== undefined &&
+      object.message?.position !== null
+    ) {
+      message.message = { $case: "position", position: Position.fromPartial(object.message.position) };
+    }
+    if (
+      object.message?.$case === "profileVersion" &&
+      object.message?.profileVersion !== undefined &&
+      object.message?.profileVersion !== null
+    ) {
+      message.message = {
+        $case: "profileVersion",
+        profileVersion: AnnounceProfileVersion.fromPartial(object.message.profileVersion),
+      };
+    }
+    if (
+      object.message?.$case === "profileRequest" &&
+      object.message?.profileRequest !== undefined &&
+      object.message?.profileRequest !== null
+    ) {
+      message.message = {
+        $case: "profileRequest",
+        profileRequest: ProfileRequest.fromPartial(object.message.profileRequest),
+      };
+    }
+    if (
+      object.message?.$case === "profileResponse" &&
+      object.message?.profileResponse !== undefined &&
+      object.message?.profileResponse !== null
+    ) {
+      message.message = {
+        $case: "profileResponse",
+        profileResponse: ProfileResponse.fromPartial(object.message.profileResponse),
+      };
+    }
+    if (object.message?.$case === "chat" && object.message?.chat !== undefined && object.message?.chat !== null) {
+      message.message = { $case: "chat", chat: Chat.fromPartial(object.message.chat) };
+    }
+    if (object.message?.$case === "scene" && object.message?.scene !== undefined && object.message?.scene !== null) {
+      message.message = { $case: "scene", scene: Scene.fromPartial(object.message.scene) };
+    }
+    if (object.message?.$case === "voice" && object.message?.voice !== undefined && object.message?.voice !== null) {
+      message.message = { $case: "voice", voice: Voice.fromPartial(object.message.voice) };
+    }
+    if (
+      object.message?.$case === "movement" &&
+      object.message?.movement !== undefined &&
+      object.message?.movement !== null
+    ) {
+      message.message = { $case: "movement", movement: Movement.fromPartial(object.message.movement) };
+    }
+    if (
+      object.message?.$case === "playerEmote" &&
+      object.message?.playerEmote !== undefined &&
+      object.message?.playerEmote !== null
+    ) {
+      message.message = { $case: "playerEmote", playerEmote: PlayerEmote.fromPartial(object.message.playerEmote) };
+    }
+    if (
+      object.message?.$case === "sceneEmote" &&
+      object.message?.sceneEmote !== undefined &&
+      object.message?.sceneEmote !== null
+    ) {
+      message.message = { $case: "sceneEmote", sceneEmote: SceneEmote.fromPartial(object.message.sceneEmote) };
+    }
+    if (
+      object.message?.$case === "movementCompressed" &&
+      object.message?.movementCompressed !== undefined &&
+      object.message?.movementCompressed !== null
+    ) {
+      message.message = {
+        $case: "movementCompressed",
+        movementCompressed: MovementCompressed.fromPartial(object.message.movementCompressed),
+      };
+    }
+    message.protocolVersion = object.protocolVersion ?? 0;
+    return message;
+  }
+}
+
+function createBasePosition(): Position {
+  return { index: 0, positionX: 0, positionY: 0, positionZ: 0, rotationX: 0, rotationY: 0, rotationZ: 0, rotationW: 0 };
+}
+
+export namespace Position {
+  export function encode(message: Position, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.index !== 0) {
+      writer.uint32(8).uint32(message.index);
+    }
+    if (message.positionX !== 0) {
+      writer.uint32(29).float(message.positionX);
+    }
+    if (message.positionY !== 0) {
+      writer.uint32(37).float(message.positionY);
+    }
+    if (message.positionZ !== 0) {
+      writer.uint32(45).float(message.positionZ);
+    }
+    if (message.rotationX !== 0) {
+      writer.uint32(53).float(message.rotationX);
+    }
+    if (message.rotationY !== 0) {
+      writer.uint32(61).float(message.rotationY);
+    }
+    if (message.rotationZ !== 0) {
+      writer.uint32(69).float(message.rotationZ);
+    }
+    if (message.rotationW !== 0) {
+      writer.uint32(77).float(message.rotationW);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Position {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePosition();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.index = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 29) {
+            break;
+          }
+
+          message.positionX = reader.float();
+          continue;
+        case 4:
+          if (tag !== 37) {
+            break;
+          }
+
+          message.positionY = reader.float();
+          continue;
+        case 5:
+          if (tag !== 45) {
+            break;
+          }
+
+          message.positionZ = reader.float();
+          continue;
+        case 6:
+          if (tag !== 53) {
+            break;
+          }
+
+          message.rotationX = reader.float();
+          continue;
+        case 7:
+          if (tag !== 61) {
+            break;
+          }
+
+          message.rotationY = reader.float();
+          continue;
+        case 8:
+          if (tag !== 69) {
+            break;
+          }
+
+          message.rotationZ = reader.float();
+          continue;
+        case 9:
+          if (tag !== 77) {
+            break;
+          }
+
+          message.rotationW = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Position {
+    return {
+      index: isSet(object.index) ? Number(object.index) : 0,
+      positionX: isSet(object.positionX) ? Number(object.positionX) : 0,
+      positionY: isSet(object.positionY) ? Number(object.positionY) : 0,
+      positionZ: isSet(object.positionZ) ? Number(object.positionZ) : 0,
+      rotationX: isSet(object.rotationX) ? Number(object.rotationX) : 0,
+      rotationY: isSet(object.rotationY) ? Number(object.rotationY) : 0,
+      rotationZ: isSet(object.rotationZ) ? Number(object.rotationZ) : 0,
+      rotationW: isSet(object.rotationW) ? Number(object.rotationW) : 0,
+    };
+  }
+
+  export function toJSON(message: Position): unknown {
+    const obj: any = {};
+    message.index !== undefined && (obj.index = Math.round(message.index));
+    message.positionX !== undefined && (obj.positionX = message.positionX);
+    message.positionY !== undefined && (obj.positionY = message.positionY);
+    message.positionZ !== undefined && (obj.positionZ = message.positionZ);
+    message.rotationX !== undefined && (obj.rotationX = message.rotationX);
+    message.rotationY !== undefined && (obj.rotationY = message.rotationY);
+    message.rotationZ !== undefined && (obj.rotationZ = message.rotationZ);
+    message.rotationW !== undefined && (obj.rotationW = message.rotationW);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Position>, I>>(base?: I): Position {
+    return Position.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Position>, I>>(object: I): Position {
+    const message = createBasePosition();
+    message.index = object.index ?? 0;
+    message.positionX = object.positionX ?? 0;
+    message.positionY = object.positionY ?? 0;
+    message.positionZ = object.positionZ ?? 0;
+    message.rotationX = object.rotationX ?? 0;
+    message.rotationY = object.rotationY ?? 0;
+    message.rotationZ = object.rotationZ ?? 0;
+    message.rotationW = object.rotationW ?? 0;
+    return message;
+  }
+}
+
+function createBaseMovement(): Movement {
+  return {
+    timestamp: 0,
+    positionX: 0,
+    positionY: 0,
+    positionZ: 0,
+    velocityX: 0,
+    velocityY: 0,
+    velocityZ: 0,
+    movementBlendValue: 0,
+    slideBlendValue: 0,
+    isGrounded: false,
+    isJumping: false,
+    jumpCount: 0,
+    isLongJump: false,
+    isLongFall: false,
+    isFalling: false,
+    isStunned: false,
+    glideState: 0,
+    rotationY: 0,
+    isInstant: false,
+    isEmoting: false,
+    headIkYawEnabled: false,
+    headIkPitchEnabled: false,
+    headYaw: 0,
+    headPitch: 0,
+    pointAtX: 0,
+    pointAtY: 0,
+    pointAtZ: 0,
+    isPointingAt: false,
+  };
+}
+
+export namespace Movement {
+  export function encode(message: Movement, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.timestamp !== 0) {
+      writer.uint32(13).float(message.timestamp);
+    }
+    if (message.positionX !== 0) {
+      writer.uint32(21).float(message.positionX);
+    }
+    if (message.positionY !== 0) {
+      writer.uint32(29).float(message.positionY);
+    }
+    if (message.positionZ !== 0) {
+      writer.uint32(37).float(message.positionZ);
+    }
+    if (message.velocityX !== 0) {
+      writer.uint32(45).float(message.velocityX);
+    }
+    if (message.velocityY !== 0) {
+      writer.uint32(53).float(message.velocityY);
+    }
+    if (message.velocityZ !== 0) {
+      writer.uint32(61).float(message.velocityZ);
+    }
+    if (message.movementBlendValue !== 0) {
+      writer.uint32(69).float(message.movementBlendValue);
+    }
+    if (message.slideBlendValue !== 0) {
+      writer.uint32(77).float(message.slideBlendValue);
+    }
+    if (message.isGrounded === true) {
+      writer.uint32(80).bool(message.isGrounded);
+    }
+    if (message.isJumping === true) {
+      writer.uint32(88).bool(message.isJumping);
+    }
+    if (message.jumpCount !== 0) {
+      writer.uint32(192).int32(message.jumpCount);
+    }
+    if (message.isLongJump === true) {
+      writer.uint32(96).bool(message.isLongJump);
+    }
+    if (message.isLongFall === true) {
+      writer.uint32(104).bool(message.isLongFall);
+    }
+    if (message.isFalling === true) {
+      writer.uint32(112).bool(message.isFalling);
+    }
+    if (message.isStunned === true) {
+      writer.uint32(120).bool(message.isStunned);
+    }
+    if (message.glideState !== 0) {
+      writer.uint32(184).int32(message.glideState);
+    }
+    if (message.rotationY !== 0) {
+      writer.uint32(133).float(message.rotationY);
+    }
+    if (message.isInstant === true) {
+      writer.uint32(136).bool(message.isInstant);
+    }
+    if (message.isEmoting === true) {
+      writer.uint32(144).bool(message.isEmoting);
+    }
+    if (message.headIkYawEnabled === true) {
+      writer.uint32(152).bool(message.headIkYawEnabled);
+    }
+    if (message.headIkPitchEnabled === true) {
+      writer.uint32(160).bool(message.headIkPitchEnabled);
+    }
+    if (message.headYaw !== 0) {
+      writer.uint32(173).float(message.headYaw);
+    }
+    if (message.headPitch !== 0) {
+      writer.uint32(181).float(message.headPitch);
+    }
+    if (message.pointAtX !== 0) {
+      writer.uint32(205).float(message.pointAtX);
+    }
+    if (message.pointAtY !== 0) {
+      writer.uint32(213).float(message.pointAtY);
+    }
+    if (message.pointAtZ !== 0) {
+      writer.uint32(221).float(message.pointAtZ);
+    }
+    if (message.isPointingAt === true) {
+      writer.uint32(224).bool(message.isPointingAt);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Movement {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMovement();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 13) {
+            break;
+          }
+
+          message.timestamp = reader.float();
+          continue;
+        case 2:
+          if (tag !== 21) {
+            break;
+          }
+
+          message.positionX = reader.float();
+          continue;
+        case 3:
+          if (tag !== 29) {
+            break;
+          }
+
+          message.positionY = reader.float();
+          continue;
+        case 4:
+          if (tag !== 37) {
+            break;
+          }
+
+          message.positionZ = reader.float();
+          continue;
+        case 5:
+          if (tag !== 45) {
+            break;
+          }
+
+          message.velocityX = reader.float();
+          continue;
+        case 6:
+          if (tag !== 53) {
+            break;
+          }
+
+          message.velocityY = reader.float();
+          continue;
+        case 7:
+          if (tag !== 61) {
+            break;
+          }
+
+          message.velocityZ = reader.float();
+          continue;
+        case 8:
+          if (tag !== 69) {
+            break;
+          }
+
+          message.movementBlendValue = reader.float();
+          continue;
+        case 9:
+          if (tag !== 77) {
+            break;
+          }
+
+          message.slideBlendValue = reader.float();
+          continue;
+        case 10:
+          if (tag !== 80) {
+            break;
+          }
+
+          message.isGrounded = reader.bool();
+          continue;
+        case 11:
+          if (tag !== 88) {
+            break;
+          }
+
+          message.isJumping = reader.bool();
+          continue;
+        case 24:
+          if (tag !== 192) {
+            break;
+          }
+
+          message.jumpCount = reader.int32();
+          continue;
+        case 12:
+          if (tag !== 96) {
+            break;
+          }
+
+          message.isLongJump = reader.bool();
+          continue;
+        case 13:
+          if (tag !== 104) {
+            break;
+          }
+
+          message.isLongFall = reader.bool();
+          continue;
+        case 14:
+          if (tag !== 112) {
+            break;
+          }
+
+          message.isFalling = reader.bool();
+          continue;
+        case 15:
+          if (tag !== 120) {
+            break;
+          }
+
+          message.isStunned = reader.bool();
+          continue;
+        case 23:
+          if (tag !== 184) {
+            break;
+          }
+
+          message.glideState = reader.int32() as any;
+          continue;
+        case 16:
+          if (tag !== 133) {
+            break;
+          }
+
+          message.rotationY = reader.float();
+          continue;
+        case 17:
+          if (tag !== 136) {
+            break;
+          }
+
+          message.isInstant = reader.bool();
+          continue;
+        case 18:
+          if (tag !== 144) {
+            break;
+          }
+
+          message.isEmoting = reader.bool();
+          continue;
+        case 19:
+          if (tag !== 152) {
+            break;
+          }
+
+          message.headIkYawEnabled = reader.bool();
+          continue;
+        case 20:
+          if (tag !== 160) {
+            break;
+          }
+
+          message.headIkPitchEnabled = reader.bool();
+          continue;
+        case 21:
+          if (tag !== 173) {
+            break;
+          }
+
+          message.headYaw = reader.float();
+          continue;
+        case 22:
+          if (tag !== 181) {
+            break;
+          }
+
+          message.headPitch = reader.float();
+          continue;
+        case 25:
+          if (tag !== 205) {
+            break;
+          }
+
+          message.pointAtX = reader.float();
+          continue;
+        case 26:
+          if (tag !== 213) {
+            break;
+          }
+
+          message.pointAtY = reader.float();
+          continue;
+        case 27:
+          if (tag !== 221) {
+            break;
+          }
+
+          message.pointAtZ = reader.float();
+          continue;
+        case 28:
+          if (tag !== 224) {
+            break;
+          }
+
+          message.isPointingAt = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Movement {
+    return {
+      timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
+      positionX: isSet(object.positionX) ? Number(object.positionX) : 0,
+      positionY: isSet(object.positionY) ? Number(object.positionY) : 0,
+      positionZ: isSet(object.positionZ) ? Number(object.positionZ) : 0,
+      velocityX: isSet(object.velocityX) ? Number(object.velocityX) : 0,
+      velocityY: isSet(object.velocityY) ? Number(object.velocityY) : 0,
+      velocityZ: isSet(object.velocityZ) ? Number(object.velocityZ) : 0,
+      movementBlendValue: isSet(object.movementBlendValue) ? Number(object.movementBlendValue) : 0,
+      slideBlendValue: isSet(object.slideBlendValue) ? Number(object.slideBlendValue) : 0,
+      isGrounded: isSet(object.isGrounded) ? Boolean(object.isGrounded) : false,
+      isJumping: isSet(object.isJumping) ? Boolean(object.isJumping) : false,
+      jumpCount: isSet(object.jumpCount) ? Number(object.jumpCount) : 0,
+      isLongJump: isSet(object.isLongJump) ? Boolean(object.isLongJump) : false,
+      isLongFall: isSet(object.isLongFall) ? Boolean(object.isLongFall) : false,
+      isFalling: isSet(object.isFalling) ? Boolean(object.isFalling) : false,
+      isStunned: isSet(object.isStunned) ? Boolean(object.isStunned) : false,
+      glideState: isSet(object.glideState) ? movement_GlideStateFromJSON(object.glideState) : 0,
+      rotationY: isSet(object.rotationY) ? Number(object.rotationY) : 0,
+      isInstant: isSet(object.isInstant) ? Boolean(object.isInstant) : false,
+      isEmoting: isSet(object.isEmoting) ? Boolean(object.isEmoting) : false,
+      headIkYawEnabled: isSet(object.headIkYawEnabled) ? Boolean(object.headIkYawEnabled) : false,
+      headIkPitchEnabled: isSet(object.headIkPitchEnabled) ? Boolean(object.headIkPitchEnabled) : false,
+      headYaw: isSet(object.headYaw) ? Number(object.headYaw) : 0,
+      headPitch: isSet(object.headPitch) ? Number(object.headPitch) : 0,
+      pointAtX: isSet(object.pointAtX) ? Number(object.pointAtX) : 0,
+      pointAtY: isSet(object.pointAtY) ? Number(object.pointAtY) : 0,
+      pointAtZ: isSet(object.pointAtZ) ? Number(object.pointAtZ) : 0,
+      isPointingAt: isSet(object.isPointingAt) ? Boolean(object.isPointingAt) : false,
+    };
+  }
+
+  export function toJSON(message: Movement): unknown {
+    const obj: any = {};
+    message.timestamp !== undefined && (obj.timestamp = message.timestamp);
+    message.positionX !== undefined && (obj.positionX = message.positionX);
+    message.positionY !== undefined && (obj.positionY = message.positionY);
+    message.positionZ !== undefined && (obj.positionZ = message.positionZ);
+    message.velocityX !== undefined && (obj.velocityX = message.velocityX);
+    message.velocityY !== undefined && (obj.velocityY = message.velocityY);
+    message.velocityZ !== undefined && (obj.velocityZ = message.velocityZ);
+    message.movementBlendValue !== undefined && (obj.movementBlendValue = message.movementBlendValue);
+    message.slideBlendValue !== undefined && (obj.slideBlendValue = message.slideBlendValue);
+    message.isGrounded !== undefined && (obj.isGrounded = message.isGrounded);
+    message.isJumping !== undefined && (obj.isJumping = message.isJumping);
+    message.jumpCount !== undefined && (obj.jumpCount = Math.round(message.jumpCount));
+    message.isLongJump !== undefined && (obj.isLongJump = message.isLongJump);
+    message.isLongFall !== undefined && (obj.isLongFall = message.isLongFall);
+    message.isFalling !== undefined && (obj.isFalling = message.isFalling);
+    message.isStunned !== undefined && (obj.isStunned = message.isStunned);
+    message.glideState !== undefined && (obj.glideState = movement_GlideStateToJSON(message.glideState));
+    message.rotationY !== undefined && (obj.rotationY = message.rotationY);
+    message.isInstant !== undefined && (obj.isInstant = message.isInstant);
+    message.isEmoting !== undefined && (obj.isEmoting = message.isEmoting);
+    message.headIkYawEnabled !== undefined && (obj.headIkYawEnabled = message.headIkYawEnabled);
+    message.headIkPitchEnabled !== undefined && (obj.headIkPitchEnabled = message.headIkPitchEnabled);
+    message.headYaw !== undefined && (obj.headYaw = message.headYaw);
+    message.headPitch !== undefined && (obj.headPitch = message.headPitch);
+    message.pointAtX !== undefined && (obj.pointAtX = message.pointAtX);
+    message.pointAtY !== undefined && (obj.pointAtY = message.pointAtY);
+    message.pointAtZ !== undefined && (obj.pointAtZ = message.pointAtZ);
+    message.isPointingAt !== undefined && (obj.isPointingAt = message.isPointingAt);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Movement>, I>>(base?: I): Movement {
+    return Movement.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Movement>, I>>(object: I): Movement {
+    const message = createBaseMovement();
+    message.timestamp = object.timestamp ?? 0;
+    message.positionX = object.positionX ?? 0;
+    message.positionY = object.positionY ?? 0;
+    message.positionZ = object.positionZ ?? 0;
+    message.velocityX = object.velocityX ?? 0;
+    message.velocityY = object.velocityY ?? 0;
+    message.velocityZ = object.velocityZ ?? 0;
+    message.movementBlendValue = object.movementBlendValue ?? 0;
+    message.slideBlendValue = object.slideBlendValue ?? 0;
+    message.isGrounded = object.isGrounded ?? false;
+    message.isJumping = object.isJumping ?? false;
+    message.jumpCount = object.jumpCount ?? 0;
+    message.isLongJump = object.isLongJump ?? false;
+    message.isLongFall = object.isLongFall ?? false;
+    message.isFalling = object.isFalling ?? false;
+    message.isStunned = object.isStunned ?? false;
+    message.glideState = object.glideState ?? 0;
+    message.rotationY = object.rotationY ?? 0;
+    message.isInstant = object.isInstant ?? false;
+    message.isEmoting = object.isEmoting ?? false;
+    message.headIkYawEnabled = object.headIkYawEnabled ?? false;
+    message.headIkPitchEnabled = object.headIkPitchEnabled ?? false;
+    message.headYaw = object.headYaw ?? 0;
+    message.headPitch = object.headPitch ?? 0;
+    message.pointAtX = object.pointAtX ?? 0;
+    message.pointAtY = object.pointAtY ?? 0;
+    message.pointAtZ = object.pointAtZ ?? 0;
+    message.isPointingAt = object.isPointingAt ?? false;
+    return message;
+  }
+}
+
+function createBaseMovementCompressed(): MovementCompressed {
+  return { temporalData: 0, movementData: 0, headSyncData: 0, pointAtData: 0 };
+}
+
+export namespace MovementCompressed {
+  export function encode(message: MovementCompressed, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.temporalData !== 0) {
+      writer.uint32(8).int32(message.temporalData);
+    }
+    if (message.movementData !== 0) {
+      writer.uint32(16).int64(message.movementData);
+    }
+    if (message.headSyncData !== 0) {
+      writer.uint32(24).int32(message.headSyncData);
+    }
+    if (message.pointAtData !== 0) {
+      writer.uint32(32).int32(message.pointAtData);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): MovementCompressed {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMovementCompressed();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.temporalData = reader.int32();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.movementData = longToNumber(reader.int64() as Long);
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.headSyncData = reader.int32();
+          continue;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+
+          message.pointAtData = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): MovementCompressed {
+    return {
+      temporalData: isSet(object.temporalData) ? Number(object.temporalData) : 0,
+      movementData: isSet(object.movementData) ? Number(object.movementData) : 0,
+      headSyncData: isSet(object.headSyncData) ? Number(object.headSyncData) : 0,
+      pointAtData: isSet(object.pointAtData) ? Number(object.pointAtData) : 0,
+    };
+  }
+
+  export function toJSON(message: MovementCompressed): unknown {
+    const obj: any = {};
+    message.temporalData !== undefined && (obj.temporalData = Math.round(message.temporalData));
+    message.movementData !== undefined && (obj.movementData = Math.round(message.movementData));
+    message.headSyncData !== undefined && (obj.headSyncData = Math.round(message.headSyncData));
+    message.pointAtData !== undefined && (obj.pointAtData = Math.round(message.pointAtData));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<MovementCompressed>, I>>(base?: I): MovementCompressed {
+    return MovementCompressed.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<MovementCompressed>, I>>(object: I): MovementCompressed {
+    const message = createBaseMovementCompressed();
+    message.temporalData = object.temporalData ?? 0;
+    message.movementData = object.movementData ?? 0;
+    message.headSyncData = object.headSyncData ?? 0;
+    message.pointAtData = object.pointAtData ?? 0;
+    return message;
+  }
+}
+
+function createBasePlayerEmote(): PlayerEmote {
+  return { incrementalId: 0, urn: "", timestamp: 0 };
+}
+
+export namespace PlayerEmote {
+  export function encode(message: PlayerEmote, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.incrementalId !== 0) {
+      writer.uint32(8).uint32(message.incrementalId);
+    }
+    if (message.urn !== "") {
+      writer.uint32(18).string(message.urn);
+    }
+    if (message.timestamp !== 0) {
+      writer.uint32(29).float(message.timestamp);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PlayerEmote {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePlayerEmote();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.incrementalId = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.urn = reader.string();
+          continue;
+        case 3:
+          if (tag !== 29) {
+            break;
+          }
+
+          message.timestamp = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PlayerEmote {
+    return {
+      incrementalId: isSet(object.incrementalId) ? Number(object.incrementalId) : 0,
+      urn: isSet(object.urn) ? String(object.urn) : "",
+      timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
+    };
+  }
+
+  export function toJSON(message: PlayerEmote): unknown {
+    const obj: any = {};
+    message.incrementalId !== undefined && (obj.incrementalId = Math.round(message.incrementalId));
+    message.urn !== undefined && (obj.urn = message.urn);
+    message.timestamp !== undefined && (obj.timestamp = message.timestamp);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PlayerEmote>, I>>(base?: I): PlayerEmote {
+    return PlayerEmote.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PlayerEmote>, I>>(object: I): PlayerEmote {
+    const message = createBasePlayerEmote();
+    message.incrementalId = object.incrementalId ?? 0;
+    message.urn = object.urn ?? "";
+    message.timestamp = object.timestamp ?? 0;
+    return message;
+  }
+}
+
+function createBaseSceneEmote(): SceneEmote {
+  return { sceneEntityId: "", source: "" };
+}
+
+export namespace SceneEmote {
+  export function encode(message: SceneEmote, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.sceneEntityId !== "") {
+      writer.uint32(10).string(message.sceneEntityId);
+    }
+    if (message.source !== "") {
+      writer.uint32(18).string(message.source);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SceneEmote {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSceneEmote();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.sceneEntityId = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.source = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): SceneEmote {
+    return {
+      sceneEntityId: isSet(object.sceneEntityId) ? String(object.sceneEntityId) : "",
+      source: isSet(object.source) ? String(object.source) : "",
+    };
+  }
+
+  export function toJSON(message: SceneEmote): unknown {
+    const obj: any = {};
+    message.sceneEntityId !== undefined && (obj.sceneEntityId = message.sceneEntityId);
+    message.source !== undefined && (obj.source = message.source);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SceneEmote>, I>>(base?: I): SceneEmote {
+    return SceneEmote.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SceneEmote>, I>>(object: I): SceneEmote {
+    const message = createBaseSceneEmote();
+    message.sceneEntityId = object.sceneEntityId ?? "";
+    message.source = object.source ?? "";
+    return message;
+  }
+}
+
+function createBaseAnnounceProfileVersion(): AnnounceProfileVersion {
+  return { profileVersion: 0 };
+}
+
+export namespace AnnounceProfileVersion {
+  export function encode(message: AnnounceProfileVersion, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.profileVersion !== 0) {
+      writer.uint32(8).uint32(message.profileVersion);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): AnnounceProfileVersion {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAnnounceProfileVersion();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.profileVersion = reader.uint32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): AnnounceProfileVersion {
+    return { profileVersion: isSet(object.profileVersion) ? Number(object.profileVersion) : 0 };
+  }
+
+  export function toJSON(message: AnnounceProfileVersion): unknown {
+    const obj: any = {};
+    message.profileVersion !== undefined && (obj.profileVersion = Math.round(message.profileVersion));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<AnnounceProfileVersion>, I>>(base?: I): AnnounceProfileVersion {
+    return AnnounceProfileVersion.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<AnnounceProfileVersion>, I>>(
+    object: I,
+  ): AnnounceProfileVersion {
+    const message = createBaseAnnounceProfileVersion();
+    message.profileVersion = object.profileVersion ?? 0;
+    return message;
+  }
+}
+
+function createBaseProfileRequest(): ProfileRequest {
+  return { address: "", profileVersion: 0 };
+}
+
+export namespace ProfileRequest {
+  export function encode(message: ProfileRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(34).string(message.address);
+    }
+    if (message.profileVersion !== 0) {
+      writer.uint32(24).uint32(message.profileVersion);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ProfileRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseProfileRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.address = reader.string();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.profileVersion = reader.uint32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ProfileRequest {
+    return {
+      address: isSet(object.address) ? String(object.address) : "",
+      profileVersion: isSet(object.profileVersion) ? Number(object.profileVersion) : 0,
+    };
+  }
+
+  export function toJSON(message: ProfileRequest): unknown {
+    const obj: any = {};
+    message.address !== undefined && (obj.address = message.address);
+    message.profileVersion !== undefined && (obj.profileVersion = Math.round(message.profileVersion));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ProfileRequest>, I>>(base?: I): ProfileRequest {
+    return ProfileRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ProfileRequest>, I>>(object: I): ProfileRequest {
+    const message = createBaseProfileRequest();
+    message.address = object.address ?? "";
+    message.profileVersion = object.profileVersion ?? 0;
+    return message;
+  }
+}
+
+function createBaseProfileResponse(): ProfileResponse {
+  return { serializedProfile: "", baseUrl: "" };
+}
+
+export namespace ProfileResponse {
+  export function encode(message: ProfileResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.serializedProfile !== "") {
+      writer.uint32(10).string(message.serializedProfile);
+    }
+    if (message.baseUrl !== "") {
+      writer.uint32(18).string(message.baseUrl);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ProfileResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseProfileResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.serializedProfile = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.baseUrl = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ProfileResponse {
+    return {
+      serializedProfile: isSet(object.serializedProfile) ? String(object.serializedProfile) : "",
+      baseUrl: isSet(object.baseUrl) ? String(object.baseUrl) : "",
+    };
+  }
+
+  export function toJSON(message: ProfileResponse): unknown {
+    const obj: any = {};
+    message.serializedProfile !== undefined && (obj.serializedProfile = message.serializedProfile);
+    message.baseUrl !== undefined && (obj.baseUrl = message.baseUrl);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ProfileResponse>, I>>(base?: I): ProfileResponse {
+    return ProfileResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ProfileResponse>, I>>(object: I): ProfileResponse {
+    const message = createBaseProfileResponse();
+    message.serializedProfile = object.serializedProfile ?? "";
+    message.baseUrl = object.baseUrl ?? "";
+    return message;
+  }
+}
+
+function createBaseChat(): Chat {
+  return { message: "", timestamp: 0 };
+}
+
+export namespace Chat {
+  export function encode(message: Chat, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
+    }
+    if (message.timestamp !== 0) {
+      writer.uint32(17).double(message.timestamp);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Chat {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseChat();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+        case 2:
+          if (tag !== 17) {
+            break;
+          }
+
+          message.timestamp = reader.double();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Chat {
+    return {
+      message: isSet(object.message) ? String(object.message) : "",
+      timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
+    };
+  }
+
+  export function toJSON(message: Chat): unknown {
+    const obj: any = {};
+    message.message !== undefined && (obj.message = message.message);
+    message.timestamp !== undefined && (obj.timestamp = message.timestamp);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Chat>, I>>(base?: I): Chat {
+    return Chat.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Chat>, I>>(object: I): Chat {
+    const message = createBaseChat();
+    message.message = object.message ?? "";
+    message.timestamp = object.timestamp ?? 0;
+    return message;
+  }
+}
+
+function createBaseScene(): Scene {
+  return { sceneId: "", data: new Uint8Array(0) };
+}
+
+export namespace Scene {
+  export function encode(message: Scene, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.sceneId !== "") {
+      writer.uint32(10).string(message.sceneId);
+    }
+    if (message.data.length !== 0) {
+      writer.uint32(18).bytes(message.data);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Scene {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseScene();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.sceneId = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.data = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Scene {
+    return {
+      sceneId: isSet(object.sceneId) ? String(object.sceneId) : "",
+      data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(0),
+    };
+  }
+
+  export function toJSON(message: Scene): unknown {
+    const obj: any = {};
+    message.sceneId !== undefined && (obj.sceneId = message.sceneId);
+    message.data !== undefined &&
+      (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array(0)));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Scene>, I>>(base?: I): Scene {
+    return Scene.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Scene>, I>>(object: I): Scene {
+    const message = createBaseScene();
+    message.sceneId = object.sceneId ?? "";
+    message.data = object.data ?? new Uint8Array(0);
+    return message;
+  }
+}
+
+function createBaseVoice(): Voice {
+  return { encodedSamples: new Uint8Array(0), index: 0, codec: 0 };
+}
+
+export namespace Voice {
+  export function encode(message: Voice, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.encodedSamples.length !== 0) {
+      writer.uint32(10).bytes(message.encodedSamples);
+    }
+    if (message.index !== 0) {
+      writer.uint32(16).uint32(message.index);
+    }
+    if (message.codec !== 0) {
+      writer.uint32(24).int32(message.codec);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Voice {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseVoice();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.encodedSamples = reader.bytes();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.index = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.codec = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Voice {
+    return {
+      encodedSamples: isSet(object.encodedSamples) ? bytesFromBase64(object.encodedSamples) : new Uint8Array(0),
+      index: isSet(object.index) ? Number(object.index) : 0,
+      codec: isSet(object.codec) ? voice_VoiceCodecFromJSON(object.codec) : 0,
+    };
+  }
+
+  export function toJSON(message: Voice): unknown {
+    const obj: any = {};
+    message.encodedSamples !== undefined &&
+      (obj.encodedSamples = base64FromBytes(
+        message.encodedSamples !== undefined ? message.encodedSamples : new Uint8Array(0),
+      ));
+    message.index !== undefined && (obj.index = Math.round(message.index));
+    message.codec !== undefined && (obj.codec = voice_VoiceCodecToJSON(message.codec));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Voice>, I>>(base?: I): Voice {
+    return Voice.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Voice>, I>>(object: I): Voice {
+    const message = createBaseVoice();
+    message.encodedSamples = object.encodedSamples ?? new Uint8Array(0);
+    message.index = object.index ?? 0;
+    message.codec = object.codec ?? 0;
+    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";
+})();
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if (tsProtoGlobalThis.Buffer) {
+    return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = tsProtoGlobalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (tsProtoGlobalThis.Buffer) {
+    return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(String.fromCharCode(byte));
+    });
+    return tsProtoGlobalThis.btoa(bin.join(""));
+  }
+}
+
+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 isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}