@dcl/protocol 1.0.0-3583035976.commit-35d616d → 1.0.0-35899496093.commit-329ba0e

package/out-ts/decentraland/sdk/components/avatar_attach.gen.ts

@@ -0,0 +1,289 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/** AvatarAnchorPointType determines the part of the avatar's body that anchors the Entity. */
+export enum AvatarAnchorPointType {
+  /** AAPT_POSITION - @deprecated consider parenting to `engine.PlayerEntity`, this will attach to player position with an arbitrary offset */
+  AAPT_POSITION = 0,
+  AAPT_NAME_TAG = 1,
+  AAPT_HEAD = 4,
+  AAPT_NECK = 5,
+  AAPT_SPINE = 6,
+  AAPT_SPINE1 = 7,
+  AAPT_SPINE2 = 8,
+  AAPT_HIP = 9,
+  AAPT_LEFT_SHOULDER = 10,
+  AAPT_LEFT_ARM = 11,
+  AAPT_LEFT_FOREARM = 12,
+  AAPT_LEFT_HAND = 2,
+  AAPT_LEFT_HAND_INDEX = 13,
+  AAPT_RIGHT_SHOULDER = 14,
+  AAPT_RIGHT_ARM = 15,
+  AAPT_RIGHT_FOREARM = 16,
+  AAPT_RIGHT_HAND = 3,
+  AAPT_RIGHT_HAND_INDEX = 17,
+  AAPT_LEFT_UP_LEG = 18,
+  AAPT_LEFT_LEG = 19,
+  AAPT_LEFT_FOOT = 20,
+  AAPT_LEFT_TOE_BASE = 21,
+  AAPT_RIGHT_UP_LEG = 22,
+  AAPT_RIGHT_LEG = 23,
+  AAPT_RIGHT_FOOT = 24,
+  AAPT_RIGHT_TOE_BASE = 25,
+  UNRECOGNIZED = -1,
+}
+
+export function avatarAnchorPointTypeFromJSON(object: any): AvatarAnchorPointType {
+  switch (object) {
+    case 0:
+    case "AAPT_POSITION":
+      return AvatarAnchorPointType.AAPT_POSITION;
+    case 1:
+    case "AAPT_NAME_TAG":
+      return AvatarAnchorPointType.AAPT_NAME_TAG;
+    case 4:
+    case "AAPT_HEAD":
+      return AvatarAnchorPointType.AAPT_HEAD;
+    case 5:
+    case "AAPT_NECK":
+      return AvatarAnchorPointType.AAPT_NECK;
+    case 6:
+    case "AAPT_SPINE":
+      return AvatarAnchorPointType.AAPT_SPINE;
+    case 7:
+    case "AAPT_SPINE1":
+      return AvatarAnchorPointType.AAPT_SPINE1;
+    case 8:
+    case "AAPT_SPINE2":
+      return AvatarAnchorPointType.AAPT_SPINE2;
+    case 9:
+    case "AAPT_HIP":
+      return AvatarAnchorPointType.AAPT_HIP;
+    case 10:
+    case "AAPT_LEFT_SHOULDER":
+      return AvatarAnchorPointType.AAPT_LEFT_SHOULDER;
+    case 11:
+    case "AAPT_LEFT_ARM":
+      return AvatarAnchorPointType.AAPT_LEFT_ARM;
+    case 12:
+    case "AAPT_LEFT_FOREARM":
+      return AvatarAnchorPointType.AAPT_LEFT_FOREARM;
+    case 2:
+    case "AAPT_LEFT_HAND":
+      return AvatarAnchorPointType.AAPT_LEFT_HAND;
+    case 13:
+    case "AAPT_LEFT_HAND_INDEX":
+      return AvatarAnchorPointType.AAPT_LEFT_HAND_INDEX;
+    case 14:
+    case "AAPT_RIGHT_SHOULDER":
+      return AvatarAnchorPointType.AAPT_RIGHT_SHOULDER;
+    case 15:
+    case "AAPT_RIGHT_ARM":
+      return AvatarAnchorPointType.AAPT_RIGHT_ARM;
+    case 16:
+    case "AAPT_RIGHT_FOREARM":
+      return AvatarAnchorPointType.AAPT_RIGHT_FOREARM;
+    case 3:
+    case "AAPT_RIGHT_HAND":
+      return AvatarAnchorPointType.AAPT_RIGHT_HAND;
+    case 17:
+    case "AAPT_RIGHT_HAND_INDEX":
+      return AvatarAnchorPointType.AAPT_RIGHT_HAND_INDEX;
+    case 18:
+    case "AAPT_LEFT_UP_LEG":
+      return AvatarAnchorPointType.AAPT_LEFT_UP_LEG;
+    case 19:
+    case "AAPT_LEFT_LEG":
+      return AvatarAnchorPointType.AAPT_LEFT_LEG;
+    case 20:
+    case "AAPT_LEFT_FOOT":
+      return AvatarAnchorPointType.AAPT_LEFT_FOOT;
+    case 21:
+    case "AAPT_LEFT_TOE_BASE":
+      return AvatarAnchorPointType.AAPT_LEFT_TOE_BASE;
+    case 22:
+    case "AAPT_RIGHT_UP_LEG":
+      return AvatarAnchorPointType.AAPT_RIGHT_UP_LEG;
+    case 23:
+    case "AAPT_RIGHT_LEG":
+      return AvatarAnchorPointType.AAPT_RIGHT_LEG;
+    case 24:
+    case "AAPT_RIGHT_FOOT":
+      return AvatarAnchorPointType.AAPT_RIGHT_FOOT;
+    case 25:
+    case "AAPT_RIGHT_TOE_BASE":
+      return AvatarAnchorPointType.AAPT_RIGHT_TOE_BASE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return AvatarAnchorPointType.UNRECOGNIZED;
+  }
+}
+
+export function avatarAnchorPointTypeToJSON(object: AvatarAnchorPointType): string {
+  switch (object) {
+    case AvatarAnchorPointType.AAPT_POSITION:
+      return "AAPT_POSITION";
+    case AvatarAnchorPointType.AAPT_NAME_TAG:
+      return "AAPT_NAME_TAG";
+    case AvatarAnchorPointType.AAPT_HEAD:
+      return "AAPT_HEAD";
+    case AvatarAnchorPointType.AAPT_NECK:
+      return "AAPT_NECK";
+    case AvatarAnchorPointType.AAPT_SPINE:
+      return "AAPT_SPINE";
+    case AvatarAnchorPointType.AAPT_SPINE1:
+      return "AAPT_SPINE1";
+    case AvatarAnchorPointType.AAPT_SPINE2:
+      return "AAPT_SPINE2";
+    case AvatarAnchorPointType.AAPT_HIP:
+      return "AAPT_HIP";
+    case AvatarAnchorPointType.AAPT_LEFT_SHOULDER:
+      return "AAPT_LEFT_SHOULDER";
+    case AvatarAnchorPointType.AAPT_LEFT_ARM:
+      return "AAPT_LEFT_ARM";
+    case AvatarAnchorPointType.AAPT_LEFT_FOREARM:
+      return "AAPT_LEFT_FOREARM";
+    case AvatarAnchorPointType.AAPT_LEFT_HAND:
+      return "AAPT_LEFT_HAND";
+    case AvatarAnchorPointType.AAPT_LEFT_HAND_INDEX:
+      return "AAPT_LEFT_HAND_INDEX";
+    case AvatarAnchorPointType.AAPT_RIGHT_SHOULDER:
+      return "AAPT_RIGHT_SHOULDER";
+    case AvatarAnchorPointType.AAPT_RIGHT_ARM:
+      return "AAPT_RIGHT_ARM";
+    case AvatarAnchorPointType.AAPT_RIGHT_FOREARM:
+      return "AAPT_RIGHT_FOREARM";
+    case AvatarAnchorPointType.AAPT_RIGHT_HAND:
+      return "AAPT_RIGHT_HAND";
+    case AvatarAnchorPointType.AAPT_RIGHT_HAND_INDEX:
+      return "AAPT_RIGHT_HAND_INDEX";
+    case AvatarAnchorPointType.AAPT_LEFT_UP_LEG:
+      return "AAPT_LEFT_UP_LEG";
+    case AvatarAnchorPointType.AAPT_LEFT_LEG:
+      return "AAPT_LEFT_LEG";
+    case AvatarAnchorPointType.AAPT_LEFT_FOOT:
+      return "AAPT_LEFT_FOOT";
+    case AvatarAnchorPointType.AAPT_LEFT_TOE_BASE:
+      return "AAPT_LEFT_TOE_BASE";
+    case AvatarAnchorPointType.AAPT_RIGHT_UP_LEG:
+      return "AAPT_RIGHT_UP_LEG";
+    case AvatarAnchorPointType.AAPT_RIGHT_LEG:
+      return "AAPT_RIGHT_LEG";
+    case AvatarAnchorPointType.AAPT_RIGHT_FOOT:
+      return "AAPT_RIGHT_FOOT";
+    case AvatarAnchorPointType.AAPT_RIGHT_TOE_BASE:
+      return "AAPT_RIGHT_TOE_BASE";
+    case AvatarAnchorPointType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/**
+ * The AvatarAttach component automatically repositions an Entity to maintain the same position and
+ * rotation relative to some part of an avatar, called the "anchor point". The Entity
+ * will follow this anchor as it moves.
+ *
+ * The Entity's own Transform is overridden by this component. To offset position and adjust scale,
+ * add a child to the anchored Entity and set a Transform on it instead.
+ *
+ * AvatarAnchorPointType indicates which part of the avatar the Entity must follow.
+ */
+export interface PBAvatarAttach {
+  /** the user ID of the avatar (default: local user) */
+  avatarId?:
+    | string
+    | undefined;
+  /** the anchor point. */
+  anchorPointId: AvatarAnchorPointType;
+}
+
+function createBasePBAvatarAttach(): PBAvatarAttach {
+  return { avatarId: undefined, anchorPointId: 0 };
+}
+
+export namespace PBAvatarAttach {
+  export function encode(message: PBAvatarAttach, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.avatarId !== undefined) {
+      writer.uint32(10).string(message.avatarId);
+    }
+    if (message.anchorPointId !== 0) {
+      writer.uint32(16).int32(message.anchorPointId);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarAttach {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBAvatarAttach();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.avatarId = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.anchorPointId = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBAvatarAttach {
+    return {
+      avatarId: isSet(object.avatarId) ? String(object.avatarId) : undefined,
+      anchorPointId: isSet(object.anchorPointId) ? avatarAnchorPointTypeFromJSON(object.anchorPointId) : 0,
+    };
+  }
+
+  export function toJSON(message: PBAvatarAttach): unknown {
+    const obj: any = {};
+    message.avatarId !== undefined && (obj.avatarId = message.avatarId);
+    message.anchorPointId !== undefined && (obj.anchorPointId = avatarAnchorPointTypeToJSON(message.anchorPointId));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBAvatarAttach>, I>>(base?: I): PBAvatarAttach {
+    return PBAvatarAttach.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBAvatarAttach>, I>>(object: I): PBAvatarAttach {
+    const message = createBasePBAvatarAttach();
+    message.avatarId = object.avatarId ?? undefined;
+    message.anchorPointId = object.anchorPointId ?? 0;
+    return message;
+  }
+}
+
+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 isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/out-ts/decentraland/sdk/components/avatar_base.gen.ts

@@ -0,0 +1,171 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { Color3 } from "../../common/colors.gen";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/** AvatarBase sets all modifiers over the avatar's apparence. */
+export interface PBAvatarBase {
+  skinColor: Color3 | undefined;
+  eyesColor: Color3 | undefined;
+  hairColor: Color3 | undefined;
+  bodyShapeUrn: string;
+  name: string;
+  /** true while the player is speaking in voice chat; unset when the engine does not report voice activity */
+  talking?: boolean | undefined;
+}
+
+function createBasePBAvatarBase(): PBAvatarBase {
+  return {
+    skinColor: undefined,
+    eyesColor: undefined,
+    hairColor: undefined,
+    bodyShapeUrn: "",
+    name: "",
+    talking: undefined,
+  };
+}
+
+export namespace PBAvatarBase {
+  export function encode(message: PBAvatarBase, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.skinColor !== undefined) {
+      Color3.encode(message.skinColor, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.eyesColor !== undefined) {
+      Color3.encode(message.eyesColor, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.hairColor !== undefined) {
+      Color3.encode(message.hairColor, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.bodyShapeUrn !== "") {
+      writer.uint32(34).string(message.bodyShapeUrn);
+    }
+    if (message.name !== "") {
+      writer.uint32(42).string(message.name);
+    }
+    if (message.talking !== undefined) {
+      writer.uint32(48).bool(message.talking);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarBase {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBAvatarBase();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.skinColor = Color3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.eyesColor = Color3.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.hairColor = Color3.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.bodyShapeUrn = reader.string();
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        case 6:
+          if (tag !== 48) {
+            break;
+          }
+
+          message.talking = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBAvatarBase {
+    return {
+      skinColor: isSet(object.skinColor) ? Color3.fromJSON(object.skinColor) : undefined,
+      eyesColor: isSet(object.eyesColor) ? Color3.fromJSON(object.eyesColor) : undefined,
+      hairColor: isSet(object.hairColor) ? Color3.fromJSON(object.hairColor) : undefined,
+      bodyShapeUrn: isSet(object.bodyShapeUrn) ? String(object.bodyShapeUrn) : "",
+      name: isSet(object.name) ? String(object.name) : "",
+      talking: isSet(object.talking) ? Boolean(object.talking) : undefined,
+    };
+  }
+
+  export function toJSON(message: PBAvatarBase): unknown {
+    const obj: any = {};
+    message.skinColor !== undefined &&
+      (obj.skinColor = message.skinColor ? Color3.toJSON(message.skinColor) : undefined);
+    message.eyesColor !== undefined &&
+      (obj.eyesColor = message.eyesColor ? Color3.toJSON(message.eyesColor) : undefined);
+    message.hairColor !== undefined &&
+      (obj.hairColor = message.hairColor ? Color3.toJSON(message.hairColor) : undefined);
+    message.bodyShapeUrn !== undefined && (obj.bodyShapeUrn = message.bodyShapeUrn);
+    message.name !== undefined && (obj.name = message.name);
+    message.talking !== undefined && (obj.talking = message.talking);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBAvatarBase>, I>>(base?: I): PBAvatarBase {
+    return PBAvatarBase.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBAvatarBase>, I>>(object: I): PBAvatarBase {
+    const message = createBasePBAvatarBase();
+    message.skinColor = (object.skinColor !== undefined && object.skinColor !== null)
+      ? Color3.fromPartial(object.skinColor)
+      : undefined;
+    message.eyesColor = (object.eyesColor !== undefined && object.eyesColor !== null)
+      ? Color3.fromPartial(object.eyesColor)
+      : undefined;
+    message.hairColor = (object.hairColor !== undefined && object.hairColor !== null)
+      ? Color3.fromPartial(object.hairColor)
+      : undefined;
+    message.bodyShapeUrn = object.bodyShapeUrn ?? "";
+    message.name = object.name ?? "";
+    message.talking = object.talking ?? undefined;
+    return message;
+  }
+}
+
+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 isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/out-ts/decentraland/sdk/components/avatar_emote_command.gen.ts

@@ -0,0 +1,202 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { AvatarMask, avatarMaskFromJSON, avatarMaskToJSON } from "./common/avatar_mask.gen";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/** EmoteState describes the lifecycle state of an emote playback. */
+export enum EmoteState {
+  /**
+   * ES_STARTED - ES_STARTED indicates the emote started playing.
+   * This is the zero value and is used for backward compatibility — entries
+   * written by older explorers (field absent) read as "started".
+   */
+  ES_STARTED = 0,
+  /** ES_FINISHED - ES_FINISHED indicates a non-looping emote completed naturally. */
+  ES_FINISHED = 1,
+  /**
+   * ES_INTERRUPTED - ES_INTERRUPTED indicates playback was cancelled (movement, teleport,
+   * another emote superseding it, explicit stop, or scene change).
+   */
+  ES_INTERRUPTED = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function emoteStateFromJSON(object: any): EmoteState {
+  switch (object) {
+    case 0:
+    case "ES_STARTED":
+      return EmoteState.ES_STARTED;
+    case 1:
+    case "ES_FINISHED":
+      return EmoteState.ES_FINISHED;
+    case 2:
+    case "ES_INTERRUPTED":
+      return EmoteState.ES_INTERRUPTED;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return EmoteState.UNRECOGNIZED;
+  }
+}
+
+export function emoteStateToJSON(object: EmoteState): string {
+  switch (object) {
+    case EmoteState.ES_STARTED:
+      return "ES_STARTED";
+    case EmoteState.ES_FINISHED:
+      return "ES_FINISHED";
+    case EmoteState.ES_INTERRUPTED:
+      return "ES_INTERRUPTED";
+    case EmoteState.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/**
+ * AvatarEmoteCommand is a grow only value set, written by the explorer to report
+ * avatar emote playback to the scene. It is appended to every player entity in the
+ * scene (the local player and remote avatars alike).
+ */
+export interface PBAvatarEmoteCommand {
+  emoteUrn: string;
+  loop: boolean;
+  /** monotonic counter */
+  timestamp: number;
+  mask?:
+    | AvatarMask
+    | undefined;
+  /**
+   * state describes the lifecycle event for this emote entry.
+   * When absent (older explorers), defaults to ES_STARTED.
+   */
+  state?: EmoteState | undefined;
+}
+
+function createBasePBAvatarEmoteCommand(): PBAvatarEmoteCommand {
+  return { emoteUrn: "", loop: false, timestamp: 0, mask: undefined, state: undefined };
+}
+
+export namespace PBAvatarEmoteCommand {
+  export function encode(message: PBAvatarEmoteCommand, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.emoteUrn !== "") {
+      writer.uint32(10).string(message.emoteUrn);
+    }
+    if (message.loop === true) {
+      writer.uint32(16).bool(message.loop);
+    }
+    if (message.timestamp !== 0) {
+      writer.uint32(24).uint32(message.timestamp);
+    }
+    if (message.mask !== undefined) {
+      writer.uint32(32).int32(message.mask);
+    }
+    if (message.state !== undefined) {
+      writer.uint32(40).int32(message.state);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarEmoteCommand {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBAvatarEmoteCommand();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.emoteUrn = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.loop = reader.bool();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.timestamp = reader.uint32();
+          continue;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+
+          message.mask = reader.int32() as any;
+          continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+
+          message.state = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBAvatarEmoteCommand {
+    return {
+      emoteUrn: isSet(object.emoteUrn) ? String(object.emoteUrn) : "",
+      loop: isSet(object.loop) ? Boolean(object.loop) : false,
+      timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
+      mask: isSet(object.mask) ? avatarMaskFromJSON(object.mask) : undefined,
+      state: isSet(object.state) ? emoteStateFromJSON(object.state) : undefined,
+    };
+  }
+
+  export function toJSON(message: PBAvatarEmoteCommand): unknown {
+    const obj: any = {};
+    message.emoteUrn !== undefined && (obj.emoteUrn = message.emoteUrn);
+    message.loop !== undefined && (obj.loop = message.loop);
+    message.timestamp !== undefined && (obj.timestamp = Math.round(message.timestamp));
+    message.mask !== undefined && (obj.mask = message.mask !== undefined ? avatarMaskToJSON(message.mask) : undefined);
+    message.state !== undefined &&
+      (obj.state = message.state !== undefined ? emoteStateToJSON(message.state) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBAvatarEmoteCommand>, I>>(base?: I): PBAvatarEmoteCommand {
+    return PBAvatarEmoteCommand.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBAvatarEmoteCommand>, I>>(object: I): PBAvatarEmoteCommand {
+    const message = createBasePBAvatarEmoteCommand();
+    message.emoteUrn = object.emoteUrn ?? "";
+    message.loop = object.loop ?? false;
+    message.timestamp = object.timestamp ?? 0;
+    message.mask = object.mask ?? undefined;
+    message.state = object.state ?? undefined;
+    return message;
+  }
+}
+
+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 isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}