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

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

@@ -1,4 +1,5 @@
 /* eslint-disable */
+import Long from "long";
 import _m0 from "protobufjs/minimal";
 
 export const protobufPackage = "decentraland.kernel.comms.rfc4";
@@ -11,7 +12,16 @@ export interface Packet {
     | { $case: "profileResponse"; profileResponse: ProfileResponse }
     | { $case: "chat"; chat: Chat }
     | { $case: "scene"; scene: Scene }
-    | { $case: "voice"; voice: Voice };
+    | { $case: "voice"; voice: Voice }
+    | { $case: "movement"; movement: Movement }
+    | { $case: "playerEmote"; playerEmote: PlayerEmote }
+    | { $case: "sceneEmote"; sceneEmote: SceneEmote }
+    | { $case: "movementCompressed"; movementCompressed: MovementCompressed }
+    | { $case: "lookAtPosition"; lookAtPosition: LookAtPosition }
+    | { $case: "reaction"; reaction: Reaction }
+    | { $case: "chatReaction"; chatReaction: ChatReaction }
+    | undefined;
+  protocolVersion: number;
 }
 
 export interface Position {
@@ -28,6 +38,142 @@ export interface Position {
   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;
+  /** true means the emote has been stopped in the sender's client */
+  isStopping?:
+    | boolean
+    | undefined;
+  /** true when it is not the first time the looping animation plays */
+  isRepeating?:
+    | boolean
+    | undefined;
+  /** identifies an interaction univocaly, established when the start animation is triggered */
+  interactionId?:
+    | number
+    | undefined;
+  /** -1 means it does not use an outcome animation */
+  socialEmoteOutcome?:
+    | number
+    | undefined;
+  /** to a social emote started by other user */
+  isReacting?:
+    | boolean
+    | undefined;
+  /** wallet address of the user that initiated social emote */
+  socialEmoteInitiator?:
+    | string
+    | undefined;
+  /** wallet address of the user whose avatar is the target of a directed emote */
+  targetAvatar?:
+    | string
+    | undefined;
+  /** mask for which bones an animation applies to. */
+  mask?: number | undefined;
+}
+
+export interface SceneEmote {
+  sceneEntityId: string;
+  source: string;
+}
+
 export interface AnnounceProfileVersion {
   profileVersion: number;
 }
@@ -45,6 +191,11 @@ export interface ProfileResponse {
 export interface Chat {
   message: string;
   timestamp: number;
+  /**
+   * Extension: optional forwarded_from to identify the original sender when
+   * messages are forwarded through an SFU
+   */
+  forwardedFrom?: string | undefined;
 }
 
 export interface Scene {
@@ -85,79 +236,215 @@ export function voice_VoiceCodecToJSON(object: Voice_VoiceCodec): string {
   }
 }
 
+/** Message sent to force an avatar to look at a position */
+export interface LookAtPosition {
+  timestamp: number;
+  /** world position */
+  positionX: number;
+  positionY: number;
+  positionZ: number;
+  targetAvatarWalletAddress: string;
+}
+
+export interface Reaction {
+  emojiIndex: number;
+  timestamp: number;
+  count: number;
+}
+
+export interface ChatReaction {
+  emojiIndex: number;
+  messageId: string;
+  address: string;
+}
+
 function createBasePacket(): Packet {
-  return { message: undefined };
+  return { message: undefined, protocolVersion: 0 };
 }
 
-export const Packet = {
-  encode(message: Packet, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.message?.$case === "position") {
-      Position.encode(message.message.position, writer.uint32(10).fork()).ldelim();
-    }
-    if (message.message?.$case === "profileVersion") {
-      AnnounceProfileVersion.encode(message.message.profileVersion, writer.uint32(18).fork()).ldelim();
-    }
-    if (message.message?.$case === "profileRequest") {
-      ProfileRequest.encode(message.message.profileRequest, writer.uint32(26).fork()).ldelim();
+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;
+      case "lookAtPosition":
+        LookAtPosition.encode(message.message.lookAtPosition, writer.uint32(106).fork()).ldelim();
+        break;
+      case "reaction":
+        Reaction.encode(message.message.reaction, writer.uint32(114).fork()).ldelim();
+        break;
+      case "chatReaction":
+        ChatReaction.encode(message.message.chatReaction, writer.uint32(122).fork()).ldelim();
+        break;
     }
-    if (message.message?.$case === "profileResponse") {
-      ProfileResponse.encode(message.message.profileResponse, writer.uint32(34).fork()).ldelim();
-    }
-    if (message.message?.$case === "chat") {
-      Chat.encode(message.message.chat, writer.uint32(42).fork()).ldelim();
-    }
-    if (message.message?.$case === "scene") {
-      Scene.encode(message.message.scene, writer.uint32(50).fork()).ldelim();
-    }
-    if (message.message?.$case === "voice") {
-      Voice.encode(message.message.voice, writer.uint32(58).fork()).ldelim();
+    if (message.protocolVersion !== 0) {
+      writer.uint32(88).uint32(message.protocolVersion);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Packet {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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()) };
-          break;
+          continue;
         case 2:
+          if (tag !== 18) {
+            break;
+          }
+
           message.message = {
             $case: "profileVersion",
             profileVersion: AnnounceProfileVersion.decode(reader, reader.uint32()),
           };
-          break;
+          continue;
         case 3:
+          if (tag !== 26) {
+            break;
+          }
+
           message.message = { $case: "profileRequest", profileRequest: ProfileRequest.decode(reader, reader.uint32()) };
-          break;
+          continue;
         case 4:
+          if (tag !== 34) {
+            break;
+          }
+
           message.message = {
             $case: "profileResponse",
             profileResponse: ProfileResponse.decode(reader, reader.uint32()),
           };
-          break;
+          continue;
         case 5:
+          if (tag !== 42) {
+            break;
+          }
+
           message.message = { $case: "chat", chat: Chat.decode(reader, reader.uint32()) };
-          break;
+          continue;
         case 6:
+          if (tag !== 50) {
+            break;
+          }
+
           message.message = { $case: "scene", scene: Scene.decode(reader, reader.uint32()) };
-          break;
+          continue;
         case 7:
+          if (tag !== 58) {
+            break;
+          }
+
           message.message = { $case: "voice", voice: Voice.decode(reader, reader.uint32()) };
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          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 13:
+          if (tag !== 106) {
+            break;
+          }
+
+          message.message = { $case: "lookAtPosition", lookAtPosition: LookAtPosition.decode(reader, reader.uint32()) };
+          continue;
+        case 14:
+          if (tag !== 114) {
+            break;
+          }
+
+          message.message = { $case: "reaction", reaction: Reaction.decode(reader, reader.uint32()) };
+          continue;
+        case 15:
+          if (tag !== 122) {
+            break;
+          }
+
+          message.message = { $case: "chatReaction", chatReaction: ChatReaction.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;
-  },
+  }
 
-  fromJSON(object: any): Packet {
+  export function fromJSON(object: any): Packet {
     return {
       message: isSet(object.position)
         ? { $case: "position", position: Position.fromJSON(object.position) }
@@ -173,33 +460,76 @@ export const Packet = {
         ? { $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) }
+        : isSet(object.lookAtPosition)
+        ? { $case: "lookAtPosition", lookAtPosition: LookAtPosition.fromJSON(object.lookAtPosition) }
+        : isSet(object.reaction)
+        ? { $case: "reaction", reaction: Reaction.fromJSON(object.reaction) }
+        : isSet(object.chatReaction)
+        ? { $case: "chatReaction", chatReaction: ChatReaction.fromJSON(object.chatReaction) }
         : undefined,
+      protocolVersion: isSet(object.protocolVersion) ? Number(object.protocolVersion) : 0,
     };
-  },
+  }
 
-  toJSON(message: Packet): unknown {
+  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 === "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.message?.$case === "lookAtPosition" &&
+      (obj.lookAtPosition = message.message?.lookAtPosition
+        ? LookAtPosition.toJSON(message.message?.lookAtPosition)
+        : undefined);
+    message.message?.$case === "reaction" &&
+      (obj.reaction = message.message?.reaction ? Reaction.toJSON(message.message?.reaction) : undefined);
+    message.message?.$case === "chatReaction" &&
+      (obj.chatReaction = message.message?.chatReaction
+        ? ChatReaction.toJSON(message.message?.chatReaction)
+        : 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 ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<Packet>, I>>(object: I): Packet {
+  export function fromPartial<I extends Exact<DeepPartial<Packet>, I>>(object: I): Packet {
     const message = createBasePacket();
     if (
       object.message?.$case === "position" &&
@@ -247,16 +577,72 @@ export const Packet = {
     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),
+      };
+    }
+    if (
+      object.message?.$case === "lookAtPosition" &&
+      object.message?.lookAtPosition !== undefined &&
+      object.message?.lookAtPosition !== null
+    ) {
+      message.message = {
+        $case: "lookAtPosition",
+        lookAtPosition: LookAtPosition.fromPartial(object.message.lookAtPosition),
+      };
+    }
+    if (
+      object.message?.$case === "reaction" &&
+      object.message?.reaction !== undefined &&
+      object.message?.reaction !== null
+    ) {
+      message.message = { $case: "reaction", reaction: Reaction.fromPartial(object.message.reaction) };
+    }
+    if (
+      object.message?.$case === "chatReaction" &&
+      object.message?.chatReaction !== undefined &&
+      object.message?.chatReaction !== null
+    ) {
+      message.message = { $case: "chatReaction", chatReaction: ChatReaction.fromPartial(object.message.chatReaction) };
+    }
+    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 const Position = {
-  encode(message: Position, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+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);
     }
@@ -282,48 +668,81 @@ export const Position = {
       writer.uint32(77).float(message.rotationW);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Position {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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();
-          break;
+          continue;
         case 3:
+          if (tag !== 29) {
+            break;
+          }
+
           message.positionX = reader.float();
-          break;
+          continue;
         case 4:
+          if (tag !== 37) {
+            break;
+          }
+
           message.positionY = reader.float();
-          break;
+          continue;
         case 5:
+          if (tag !== 45) {
+            break;
+          }
+
           message.positionZ = reader.float();
-          break;
+          continue;
         case 6:
+          if (tag !== 53) {
+            break;
+          }
+
           message.rotationX = reader.float();
-          break;
+          continue;
         case 7:
+          if (tag !== 61) {
+            break;
+          }
+
           message.rotationY = reader.float();
-          break;
+          continue;
         case 8:
+          if (tag !== 69) {
+            break;
+          }
+
           message.rotationZ = reader.float();
-          break;
+          continue;
         case 9:
+          if (tag !== 77) {
+            break;
+          }
+
           message.rotationW = reader.float();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): Position {
+  export function fromJSON(object: any): Position {
     return {
       index: isSet(object.index) ? Number(object.index) : 0,
       positionX: isSet(object.positionX) ? Number(object.positionX) : 0,
@@ -334,9 +753,9 @@ export const Position = {
       rotationZ: isSet(object.rotationZ) ? Number(object.rotationZ) : 0,
       rotationW: isSet(object.rotationW) ? Number(object.rotationW) : 0,
     };
-  },
+  }
 
-  toJSON(message: Position): unknown {
+  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);
@@ -347,9 +766,13 @@ export const Position = {
     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 ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<Position>, I>>(object: I): Position {
+  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;
@@ -360,236 +783,1105 @@ export const Position = {
     message.rotationZ = object.rotationZ ?? 0;
     message.rotationW = object.rotationW ?? 0;
     return message;
-  },
-};
+  }
+}
 
-function createBaseAnnounceProfileVersion(): AnnounceProfileVersion {
-  return { profileVersion: 0 };
+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 const AnnounceProfileVersion = {
-  encode(message: AnnounceProfileVersion, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.profileVersion !== 0) {
-      writer.uint32(8).uint32(message.profileVersion);
+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;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): AnnounceProfileVersion {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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 = createBaseAnnounceProfileVersion();
+    const message = createBaseMovement();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.profileVersion = reader.uint32();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
+          if (tag !== 13) {
+            break;
+          }
 
-  fromJSON(object: any): AnnounceProfileVersion {
-    return { profileVersion: isSet(object.profileVersion) ? Number(object.profileVersion) : 0 };
-  },
+          message.timestamp = reader.float();
+          continue;
+        case 2:
+          if (tag !== 21) {
+            break;
+          }
 
-  toJSON(message: AnnounceProfileVersion): unknown {
-    const obj: any = {};
-    message.profileVersion !== undefined && (obj.profileVersion = Math.round(message.profileVersion));
-    return obj;
-  },
+          message.positionX = reader.float();
+          continue;
+        case 3:
+          if (tag !== 29) {
+            break;
+          }
 
-  fromPartial<I extends Exact<DeepPartial<AnnounceProfileVersion>, I>>(object: I): AnnounceProfileVersion {
-    const message = createBaseAnnounceProfileVersion();
-    message.profileVersion = object.profileVersion ?? 0;
-    return message;
-  },
-};
+          message.positionY = reader.float();
+          continue;
+        case 4:
+          if (tag !== 37) {
+            break;
+          }
 
-function createBaseProfileRequest(): ProfileRequest {
-  return { address: "", profileVersion: 0 };
-}
+          message.positionZ = reader.float();
+          continue;
+        case 5:
+          if (tag !== 45) {
+            break;
+          }
 
-export const ProfileRequest = {
-  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;
-  },
+          message.velocityX = reader.float();
+          continue;
+        case 6:
+          if (tag !== 53) {
+            break;
+          }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ProfileRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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:
-          message.address = reader.string();
-          break;
-        case 3:
-          message.profileVersion = reader.uint32();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          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;
-  },
+  }
 
-  fromJSON(object: any): ProfileRequest {
+  export function fromJSON(object: any): Movement {
     return {
-      address: isSet(object.address) ? String(object.address) : "",
-      profileVersion: isSet(object.profileVersion) ? Number(object.profileVersion) : 0,
+      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,
     };
-  },
+  }
 
-  toJSON(message: ProfileRequest): unknown {
+  export function toJSON(message: Movement): unknown {
     const obj: any = {};
-    message.address !== undefined && (obj.address = message.address);
-    message.profileVersion !== undefined && (obj.profileVersion = Math.round(message.profileVersion));
+    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;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<ProfileRequest>, I>>(object: I): ProfileRequest {
-    const message = createBaseProfileRequest();
-    message.address = object.address ?? "";
-    message.profileVersion = object.profileVersion ?? 0;
+  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 createBaseProfileResponse(): ProfileResponse {
-  return { serializedProfile: "", baseUrl: "" };
+function createBaseMovementCompressed(): MovementCompressed {
+  return { temporalData: 0, movementData: 0, headSyncData: 0, pointAtData: 0 };
 }
 
-export const ProfileResponse = {
-  encode(message: ProfileResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.serializedProfile !== "") {
-      writer.uint32(10).string(message.serializedProfile);
+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.baseUrl !== "") {
-      writer.uint32(18).string(message.baseUrl);
+    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;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ProfileResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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 = createBaseProfileResponse();
+    const message = createBaseMovementCompressed();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.serializedProfile = reader.string();
-          break;
+          if (tag !== 8) {
+            break;
+          }
+
+          message.temporalData = reader.int32();
+          continue;
         case 2:
-          message.baseUrl = reader.string();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          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;
-  },
+  }
 
-  fromJSON(object: any): ProfileResponse {
+  export function fromJSON(object: any): MovementCompressed {
     return {
-      serializedProfile: isSet(object.serializedProfile) ? String(object.serializedProfile) : "",
-      baseUrl: isSet(object.baseUrl) ? String(object.baseUrl) : "",
+      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,
     };
-  },
+  }
 
-  toJSON(message: ProfileResponse): unknown {
+  export function toJSON(message: MovementCompressed): unknown {
     const obj: any = {};
-    message.serializedProfile !== undefined && (obj.serializedProfile = message.serializedProfile);
-    message.baseUrl !== undefined && (obj.baseUrl = message.baseUrl);
+    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;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<ProfileResponse>, I>>(object: I): ProfileResponse {
-    const message = createBaseProfileResponse();
-    message.serializedProfile = object.serializedProfile ?? "";
+  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,
+    isStopping: undefined,
+    isRepeating: undefined,
+    interactionId: undefined,
+    socialEmoteOutcome: undefined,
+    isReacting: undefined,
+    socialEmoteInitiator: undefined,
+    targetAvatar: undefined,
+    mask: undefined,
+  };
+}
+
+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);
+    }
+    if (message.isStopping !== undefined) {
+      writer.uint32(32).bool(message.isStopping);
+    }
+    if (message.isRepeating !== undefined) {
+      writer.uint32(40).bool(message.isRepeating);
+    }
+    if (message.interactionId !== undefined) {
+      writer.uint32(48).int32(message.interactionId);
+    }
+    if (message.socialEmoteOutcome !== undefined) {
+      writer.uint32(56).int32(message.socialEmoteOutcome);
+    }
+    if (message.isReacting !== undefined) {
+      writer.uint32(64).bool(message.isReacting);
+    }
+    if (message.socialEmoteInitiator !== undefined) {
+      writer.uint32(74).string(message.socialEmoteInitiator);
+    }
+    if (message.targetAvatar !== undefined) {
+      writer.uint32(82).string(message.targetAvatar);
+    }
+    if (message.mask !== undefined) {
+      writer.uint32(88).uint32(message.mask);
+    }
+    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;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+
+          message.isStopping = reader.bool();
+          continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+
+          message.isRepeating = reader.bool();
+          continue;
+        case 6:
+          if (tag !== 48) {
+            break;
+          }
+
+          message.interactionId = reader.int32();
+          continue;
+        case 7:
+          if (tag !== 56) {
+            break;
+          }
+
+          message.socialEmoteOutcome = reader.int32();
+          continue;
+        case 8:
+          if (tag !== 64) {
+            break;
+          }
+
+          message.isReacting = reader.bool();
+          continue;
+        case 9:
+          if (tag !== 74) {
+            break;
+          }
+
+          message.socialEmoteInitiator = reader.string();
+          continue;
+        case 10:
+          if (tag !== 82) {
+            break;
+          }
+
+          message.targetAvatar = reader.string();
+          continue;
+        case 11:
+          if (tag !== 88) {
+            break;
+          }
+
+          message.mask = reader.uint32();
+          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,
+      isStopping: isSet(object.isStopping) ? Boolean(object.isStopping) : undefined,
+      isRepeating: isSet(object.isRepeating) ? Boolean(object.isRepeating) : undefined,
+      interactionId: isSet(object.interactionId) ? Number(object.interactionId) : undefined,
+      socialEmoteOutcome: isSet(object.socialEmoteOutcome) ? Number(object.socialEmoteOutcome) : undefined,
+      isReacting: isSet(object.isReacting) ? Boolean(object.isReacting) : undefined,
+      socialEmoteInitiator: isSet(object.socialEmoteInitiator) ? String(object.socialEmoteInitiator) : undefined,
+      targetAvatar: isSet(object.targetAvatar) ? String(object.targetAvatar) : undefined,
+      mask: isSet(object.mask) ? Number(object.mask) : undefined,
+    };
+  }
+
+  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);
+    message.isStopping !== undefined && (obj.isStopping = message.isStopping);
+    message.isRepeating !== undefined && (obj.isRepeating = message.isRepeating);
+    message.interactionId !== undefined && (obj.interactionId = Math.round(message.interactionId));
+    message.socialEmoteOutcome !== undefined && (obj.socialEmoteOutcome = Math.round(message.socialEmoteOutcome));
+    message.isReacting !== undefined && (obj.isReacting = message.isReacting);
+    message.socialEmoteInitiator !== undefined && (obj.socialEmoteInitiator = message.socialEmoteInitiator);
+    message.targetAvatar !== undefined && (obj.targetAvatar = message.targetAvatar);
+    message.mask !== undefined && (obj.mask = Math.round(message.mask));
+    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;
+    message.isStopping = object.isStopping ?? undefined;
+    message.isRepeating = object.isRepeating ?? undefined;
+    message.interactionId = object.interactionId ?? undefined;
+    message.socialEmoteOutcome = object.socialEmoteOutcome ?? undefined;
+    message.isReacting = object.isReacting ?? undefined;
+    message.socialEmoteInitiator = object.socialEmoteInitiator ?? undefined;
+    message.targetAvatar = object.targetAvatar ?? undefined;
+    message.mask = object.mask ?? undefined;
+    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 };
+  return { message: "", timestamp: 0, forwardedFrom: undefined };
 }
 
-export const Chat = {
-  encode(message: Chat, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+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);
     }
+    if (message.forwardedFrom !== undefined) {
+      writer.uint32(26).string(message.forwardedFrom);
+    }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Chat {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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();
-          break;
+          continue;
         case 2:
+          if (tag !== 17) {
+            break;
+          }
+
           message.timestamp = reader.double();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.forwardedFrom = reader.string();
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): Chat {
+  export function fromJSON(object: any): Chat {
     return {
       message: isSet(object.message) ? String(object.message) : "",
       timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
+      forwardedFrom: isSet(object.forwardedFrom) ? String(object.forwardedFrom) : undefined,
     };
-  },
+  }
 
-  toJSON(message: Chat): unknown {
+  export function toJSON(message: Chat): unknown {
     const obj: any = {};
     message.message !== undefined && (obj.message = message.message);
     message.timestamp !== undefined && (obj.timestamp = message.timestamp);
+    message.forwardedFrom !== undefined && (obj.forwardedFrom = message.forwardedFrom);
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<Chat>, I>>(base?: I): Chat {
+    return Chat.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<Chat>, I>>(object: I): Chat {
+  export function fromPartial<I extends Exact<DeepPartial<Chat>, I>>(object: I): Chat {
     const message = createBaseChat();
     message.message = object.message ?? "";
     message.timestamp = object.timestamp ?? 0;
+    message.forwardedFrom = object.forwardedFrom ?? undefined;
     return message;
-  },
-};
+  }
+}
 
 function createBaseScene(): Scene {
-  return { sceneId: "", data: new Uint8Array() };
+  return { sceneId: "", data: new Uint8Array(0) };
 }
 
-export const Scene = {
-  encode(message: Scene, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+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);
     }
@@ -597,58 +1889,71 @@ export const Scene = {
       writer.uint32(18).bytes(message.data);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Scene {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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();
-          break;
+          continue;
         case 2:
+          if (tag !== 18) {
+            break;
+          }
+
           message.data = reader.bytes();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): Scene {
+  export function fromJSON(object: any): Scene {
     return {
       sceneId: isSet(object.sceneId) ? String(object.sceneId) : "",
-      data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(),
+      data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(0),
     };
-  },
+  }
 
-  toJSON(message: Scene): unknown {
+  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()));
+      (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 ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<Scene>, I>>(object: I): Scene {
+  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();
+    message.data = object.data ?? new Uint8Array(0);
     return message;
-  },
-};
+  }
+}
 
 function createBaseVoice(): Voice {
-  return { encodedSamples: new Uint8Array(), index: 0, codec: 0 };
+  return { encodedSamples: new Uint8Array(0), index: 0, codec: 0 };
 }
 
-export const Voice = {
-  encode(message: Voice, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+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);
     }
@@ -659,64 +1964,362 @@ export const Voice = {
       writer.uint32(24).int32(message.codec);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Voice {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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();
-          break;
+          continue;
         case 2:
+          if (tag !== 16) {
+            break;
+          }
+
           message.index = reader.uint32();
-          break;
+          continue;
         case 3:
+          if (tag !== 24) {
+            break;
+          }
+
           message.codec = reader.int32() as any;
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): Voice {
+  export function fromJSON(object: any): Voice {
     return {
-      encodedSamples: isSet(object.encodedSamples) ? bytesFromBase64(object.encodedSamples) : new Uint8Array(),
+      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,
     };
-  },
+  }
 
-  toJSON(message: Voice): unknown {
+  export function toJSON(message: Voice): unknown {
     const obj: any = {};
     message.encodedSamples !== undefined &&
       (obj.encodedSamples = base64FromBytes(
-        message.encodedSamples !== undefined ? message.encodedSamples : new Uint8Array(),
+        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;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<Voice>, I>>(object: I): Voice {
+  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();
+    message.encodedSamples = object.encodedSamples ?? new Uint8Array(0);
     message.index = object.index ?? 0;
     message.codec = object.codec ?? 0;
     return message;
-  },
-};
+  }
+}
+
+function createBaseLookAtPosition(): LookAtPosition {
+  return { timestamp: 0, positionX: 0, positionY: 0, positionZ: 0, targetAvatarWalletAddress: "" };
+}
+
+export namespace LookAtPosition {
+  export function encode(message: LookAtPosition, 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.targetAvatarWalletAddress !== "") {
+      writer.uint32(42).string(message.targetAvatarWalletAddress);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): LookAtPosition {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLookAtPosition();
+    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 !== 42) {
+            break;
+          }
+
+          message.targetAvatarWalletAddress = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
 
-declare var self: any | undefined;
-declare var window: any | undefined;
-declare var global: any | undefined;
-var globalThis: any = (() => {
+  export function fromJSON(object: any): LookAtPosition {
+    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,
+      targetAvatarWalletAddress: isSet(object.targetAvatarWalletAddress)
+        ? String(object.targetAvatarWalletAddress)
+        : "",
+    };
+  }
+
+  export function toJSON(message: LookAtPosition): 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.targetAvatarWalletAddress !== undefined &&
+      (obj.targetAvatarWalletAddress = message.targetAvatarWalletAddress);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<LookAtPosition>, I>>(base?: I): LookAtPosition {
+    return LookAtPosition.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<LookAtPosition>, I>>(object: I): LookAtPosition {
+    const message = createBaseLookAtPosition();
+    message.timestamp = object.timestamp ?? 0;
+    message.positionX = object.positionX ?? 0;
+    message.positionY = object.positionY ?? 0;
+    message.positionZ = object.positionZ ?? 0;
+    message.targetAvatarWalletAddress = object.targetAvatarWalletAddress ?? "";
+    return message;
+  }
+}
+
+function createBaseReaction(): Reaction {
+  return { emojiIndex: 0, timestamp: 0, count: 0 };
+}
+
+export namespace Reaction {
+  export function encode(message: Reaction, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.emojiIndex !== 0) {
+      writer.uint32(8).int32(message.emojiIndex);
+    }
+    if (message.timestamp !== 0) {
+      writer.uint32(21).float(message.timestamp);
+    }
+    if (message.count !== 0) {
+      writer.uint32(24).int32(message.count);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Reaction {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReaction();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.emojiIndex = reader.int32();
+          continue;
+        case 2:
+          if (tag !== 21) {
+            break;
+          }
+
+          message.timestamp = reader.float();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.count = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Reaction {
+    return {
+      emojiIndex: isSet(object.emojiIndex) ? Number(object.emojiIndex) : 0,
+      timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
+      count: isSet(object.count) ? Number(object.count) : 0,
+    };
+  }
+
+  export function toJSON(message: Reaction): unknown {
+    const obj: any = {};
+    message.emojiIndex !== undefined && (obj.emojiIndex = Math.round(message.emojiIndex));
+    message.timestamp !== undefined && (obj.timestamp = message.timestamp);
+    message.count !== undefined && (obj.count = Math.round(message.count));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Reaction>, I>>(base?: I): Reaction {
+    return Reaction.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Reaction>, I>>(object: I): Reaction {
+    const message = createBaseReaction();
+    message.emojiIndex = object.emojiIndex ?? 0;
+    message.timestamp = object.timestamp ?? 0;
+    message.count = object.count ?? 0;
+    return message;
+  }
+}
+
+function createBaseChatReaction(): ChatReaction {
+  return { emojiIndex: 0, messageId: "", address: "" };
+}
+
+export namespace ChatReaction {
+  export function encode(message: ChatReaction, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.emojiIndex !== 0) {
+      writer.uint32(8).int32(message.emojiIndex);
+    }
+    if (message.messageId !== "") {
+      writer.uint32(18).string(message.messageId);
+    }
+    if (message.address !== "") {
+      writer.uint32(26).string(message.address);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ChatReaction {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseChatReaction();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.emojiIndex = reader.int32();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.messageId = reader.string();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.address = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ChatReaction {
+    return {
+      emojiIndex: isSet(object.emojiIndex) ? Number(object.emojiIndex) : 0,
+      messageId: isSet(object.messageId) ? String(object.messageId) : "",
+      address: isSet(object.address) ? String(object.address) : "",
+    };
+  }
+
+  export function toJSON(message: ChatReaction): unknown {
+    const obj: any = {};
+    message.emojiIndex !== undefined && (obj.emojiIndex = Math.round(message.emojiIndex));
+    message.messageId !== undefined && (obj.messageId = message.messageId);
+    message.address !== undefined && (obj.address = message.address);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ChatReaction>, I>>(base?: I): ChatReaction {
+    return ChatReaction.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ChatReaction>, I>>(object: I): ChatReaction {
+    const message = createBaseChatReaction();
+    message.emojiIndex = object.emojiIndex ?? 0;
+    message.messageId = object.messageId ?? "";
+    message.address = object.address ?? "";
+    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;
   }
@@ -733,10 +2336,10 @@ var globalThis: any = (() => {
 })();
 
 function bytesFromBase64(b64: string): Uint8Array {
-  if (globalThis.Buffer) {
-    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  if (tsProtoGlobalThis.Buffer) {
+    return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
   } else {
-    const bin = globalThis.atob(b64);
+    const bin = tsProtoGlobalThis.atob(b64);
     const arr = new Uint8Array(bin.length);
     for (let i = 0; i < bin.length; ++i) {
       arr[i] = bin.charCodeAt(i);
@@ -746,14 +2349,14 @@ function bytesFromBase64(b64: string): Uint8Array {
 }
 
 function base64FromBytes(arr: Uint8Array): string {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.from(arr).toString("base64");
+  if (tsProtoGlobalThis.Buffer) {
+    return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
   } else {
     const bin: string[] = [];
     arr.forEach((byte) => {
       bin.push(String.fromCharCode(byte));
     });
-    return globalThis.btoa(bin.join(""));
+    return tsProtoGlobalThis.btoa(bin.join(""));
   }
 }
 
@@ -769,6 +2372,18 @@ type KeysOfUnion<T> = T extends T ? keyof T : never;
 export type Exact<P, I extends P> = P extends Builtin ? P
   : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
 
+function longToNumber(long: Long): number {
+  if (long.gt(Number.MAX_SAFE_INTEGER)) {
+    throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
 function isSet(value: any): boolean {
   return value !== null && value !== undefined;
 }