@dcl/protocol 1.0.0-10043247792.commit-428d1eb

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,149 @@
+/* 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;
+}
+
+function createBasePBAvatarBase(): PBAvatarBase {
+  return { skinColor: undefined, eyesColor: undefined, hairColor: undefined, bodyShapeUrn: "", name: "" };
+}
+
+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);
+    }
+    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;
+      }
+      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) : "",
+    };
+  }
+
+  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);
+    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 ?? "";
+    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,115 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/**
+ * AvatarEmoteCommand is a grow only value set, used to signal the renderer about
+ * avatar emotes playback.
+ */
+export interface PBAvatarEmoteCommand {
+  emoteUrn: string;
+  loop: boolean;
+  /** monotonic counter */
+  timestamp: number;
+}
+
+function createBasePBAvatarEmoteCommand(): PBAvatarEmoteCommand {
+  return { emoteUrn: "", loop: false, timestamp: 0 };
+}
+
+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);
+    }
+    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;
+      }
+      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,
+    };
+  }
+
+  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));
+    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;
+    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_equipped_data.gen.ts

@@ -0,0 +1,105 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/**
+ * AvatarEquipData is used to read the information about the avatar's owneables.
+ * this component is written by the engine using the communications transports'
+ * data.
+ */
+export interface PBAvatarEquippedData {
+  wearableUrns: string[];
+  emoteUrns: string[];
+}
+
+function createBasePBAvatarEquippedData(): PBAvatarEquippedData {
+  return { wearableUrns: [], emoteUrns: [] };
+}
+
+export namespace PBAvatarEquippedData {
+  export function encode(message: PBAvatarEquippedData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.wearableUrns) {
+      writer.uint32(10).string(v!);
+    }
+    for (const v of message.emoteUrns) {
+      writer.uint32(18).string(v!);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarEquippedData {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBAvatarEquippedData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.wearableUrns.push(reader.string());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.emoteUrns.push(reader.string());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBAvatarEquippedData {
+    return {
+      wearableUrns: Array.isArray(object?.wearableUrns) ? object.wearableUrns.map((e: any) => String(e)) : [],
+      emoteUrns: Array.isArray(object?.emoteUrns) ? object.emoteUrns.map((e: any) => String(e)) : [],
+    };
+  }
+
+  export function toJSON(message: PBAvatarEquippedData): unknown {
+    const obj: any = {};
+    if (message.wearableUrns) {
+      obj.wearableUrns = message.wearableUrns.map((e) => e);
+    } else {
+      obj.wearableUrns = [];
+    }
+    if (message.emoteUrns) {
+      obj.emoteUrns = message.emoteUrns.map((e) => e);
+    } else {
+      obj.emoteUrns = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBAvatarEquippedData>, I>>(base?: I): PBAvatarEquippedData {
+    return PBAvatarEquippedData.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBAvatarEquippedData>, I>>(object: I): PBAvatarEquippedData {
+    const message = createBasePBAvatarEquippedData();
+    message.wearableUrns = object.wearableUrns?.map((e) => e) || [];
+    message.emoteUrns = object.emoteUrns?.map((e) => e) || [];
+    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 };