@dcl/protocol 1.0.0-4427886959.commit-6b9dcb5 → 1.0.0-4440731539.commit-a2174f5

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

@@ -0,0 +1,395 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/**
+ * The MeshRenderer component renders a basic geometric shape for an Entity. It can be a cube, a
+ * plane, a sphere or a cylinder.
+ *
+ * The cube and plane variants can include a UV texture mapping, so specific areas of a material
+ * texture are rendered on different faces of the shape. They are serialized as a sequence of 2D
+ * `float` coordinates, one for each corner of each side of each face.
+ *
+ * More complex shapes require the use of a `GltfContainer` component.
+ */
+export interface PBMeshRenderer {
+  mesh?: { $case: "box"; box: PBMeshRenderer_BoxMesh } | { $case: "sphere"; sphere: PBMeshRenderer_SphereMesh } | {
+    $case: "cylinder";
+    cylinder: PBMeshRenderer_CylinderMesh;
+  } | { $case: "plane"; plane: PBMeshRenderer_PlaneMesh };
+}
+
+/** BoxMesh renders a prism shape. */
+export interface PBMeshRenderer_BoxMesh {
+  /** 96-value texture map (2D * 6 faces * 2 sides * 4 vertices) */
+  uvs: number[];
+}
+
+/** CylinderMesh renders a truncated cone shape. */
+export interface PBMeshRenderer_CylinderMesh {
+  /** (default 1.0) */
+  radiusTop?:
+    | number
+    | undefined;
+  /** (default 1.0) */
+  radiusBottom?: number | undefined;
+}
+
+/** PlaneMesh renders a 2D rectangular shape. */
+export interface PBMeshRenderer_PlaneMesh {
+  /** 16-value texture map (2D * 1 face * 2 sides * 4 vertices) */
+  uvs: number[];
+}
+
+/** SphereMesh renders a spherical shape. */
+export interface PBMeshRenderer_SphereMesh {
+}
+
+function createBasePBMeshRenderer(): PBMeshRenderer {
+  return { mesh: undefined };
+}
+
+export const PBMeshRenderer = {
+  encode(message: PBMeshRenderer, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.mesh?.$case) {
+      case "box":
+        PBMeshRenderer_BoxMesh.encode(message.mesh.box, writer.uint32(10).fork()).ldelim();
+        break;
+      case "sphere":
+        PBMeshRenderer_SphereMesh.encode(message.mesh.sphere, writer.uint32(18).fork()).ldelim();
+        break;
+      case "cylinder":
+        PBMeshRenderer_CylinderMesh.encode(message.mesh.cylinder, writer.uint32(26).fork()).ldelim();
+        break;
+      case "plane":
+        PBMeshRenderer_PlaneMesh.encode(message.mesh.plane, writer.uint32(34).fork()).ldelim();
+        break;
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBMeshRenderer();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.mesh = { $case: "box", box: PBMeshRenderer_BoxMesh.decode(reader, reader.uint32()) };
+          break;
+        case 2:
+          message.mesh = { $case: "sphere", sphere: PBMeshRenderer_SphereMesh.decode(reader, reader.uint32()) };
+          break;
+        case 3:
+          message.mesh = { $case: "cylinder", cylinder: PBMeshRenderer_CylinderMesh.decode(reader, reader.uint32()) };
+          break;
+        case 4:
+          message.mesh = { $case: "plane", plane: PBMeshRenderer_PlaneMesh.decode(reader, reader.uint32()) };
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PBMeshRenderer {
+    return {
+      mesh: isSet(object.box)
+        ? { $case: "box", box: PBMeshRenderer_BoxMesh.fromJSON(object.box) }
+        : isSet(object.sphere)
+        ? { $case: "sphere", sphere: PBMeshRenderer_SphereMesh.fromJSON(object.sphere) }
+        : isSet(object.cylinder)
+        ? { $case: "cylinder", cylinder: PBMeshRenderer_CylinderMesh.fromJSON(object.cylinder) }
+        : isSet(object.plane)
+        ? { $case: "plane", plane: PBMeshRenderer_PlaneMesh.fromJSON(object.plane) }
+        : undefined,
+    };
+  },
+
+  toJSON(message: PBMeshRenderer): unknown {
+    const obj: any = {};
+    message.mesh?.$case === "box" &&
+      (obj.box = message.mesh?.box ? PBMeshRenderer_BoxMesh.toJSON(message.mesh?.box) : undefined);
+    message.mesh?.$case === "sphere" &&
+      (obj.sphere = message.mesh?.sphere ? PBMeshRenderer_SphereMesh.toJSON(message.mesh?.sphere) : undefined);
+    message.mesh?.$case === "cylinder" &&
+      (obj.cylinder = message.mesh?.cylinder ? PBMeshRenderer_CylinderMesh.toJSON(message.mesh?.cylinder) : undefined);
+    message.mesh?.$case === "plane" &&
+      (obj.plane = message.mesh?.plane ? PBMeshRenderer_PlaneMesh.toJSON(message.mesh?.plane) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PBMeshRenderer>, I>>(base?: I): PBMeshRenderer {
+    return PBMeshRenderer.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PBMeshRenderer>, I>>(object: I): PBMeshRenderer {
+    const message = createBasePBMeshRenderer();
+    if (object.mesh?.$case === "box" && object.mesh?.box !== undefined && object.mesh?.box !== null) {
+      message.mesh = { $case: "box", box: PBMeshRenderer_BoxMesh.fromPartial(object.mesh.box) };
+    }
+    if (object.mesh?.$case === "sphere" && object.mesh?.sphere !== undefined && object.mesh?.sphere !== null) {
+      message.mesh = { $case: "sphere", sphere: PBMeshRenderer_SphereMesh.fromPartial(object.mesh.sphere) };
+    }
+    if (object.mesh?.$case === "cylinder" && object.mesh?.cylinder !== undefined && object.mesh?.cylinder !== null) {
+      message.mesh = { $case: "cylinder", cylinder: PBMeshRenderer_CylinderMesh.fromPartial(object.mesh.cylinder) };
+    }
+    if (object.mesh?.$case === "plane" && object.mesh?.plane !== undefined && object.mesh?.plane !== null) {
+      message.mesh = { $case: "plane", plane: PBMeshRenderer_PlaneMesh.fromPartial(object.mesh.plane) };
+    }
+    return message;
+  },
+};
+
+function createBasePBMeshRenderer_BoxMesh(): PBMeshRenderer_BoxMesh {
+  return { uvs: [] };
+}
+
+export const PBMeshRenderer_BoxMesh = {
+  encode(message: PBMeshRenderer_BoxMesh, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    writer.uint32(10).fork();
+    for (const v of message.uvs) {
+      writer.float(v);
+    }
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_BoxMesh {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBMeshRenderer_BoxMesh();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.uvs.push(reader.float());
+            }
+          } else {
+            message.uvs.push(reader.float());
+          }
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PBMeshRenderer_BoxMesh {
+    return { uvs: Array.isArray(object?.uvs) ? object.uvs.map((e: any) => Number(e)) : [] };
+  },
+
+  toJSON(message: PBMeshRenderer_BoxMesh): unknown {
+    const obj: any = {};
+    if (message.uvs) {
+      obj.uvs = message.uvs.map((e) => e);
+    } else {
+      obj.uvs = [];
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PBMeshRenderer_BoxMesh>, I>>(base?: I): PBMeshRenderer_BoxMesh {
+    return PBMeshRenderer_BoxMesh.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PBMeshRenderer_BoxMesh>, I>>(object: I): PBMeshRenderer_BoxMesh {
+    const message = createBasePBMeshRenderer_BoxMesh();
+    message.uvs = object.uvs?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBasePBMeshRenderer_CylinderMesh(): PBMeshRenderer_CylinderMesh {
+  return { radiusTop: undefined, radiusBottom: undefined };
+}
+
+export const PBMeshRenderer_CylinderMesh = {
+  encode(message: PBMeshRenderer_CylinderMesh, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.radiusTop !== undefined) {
+      writer.uint32(13).float(message.radiusTop);
+    }
+    if (message.radiusBottom !== undefined) {
+      writer.uint32(21).float(message.radiusBottom);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_CylinderMesh {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBMeshRenderer_CylinderMesh();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.radiusTop = reader.float();
+          break;
+        case 2:
+          message.radiusBottom = reader.float();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PBMeshRenderer_CylinderMesh {
+    return {
+      radiusTop: isSet(object.radiusTop) ? Number(object.radiusTop) : undefined,
+      radiusBottom: isSet(object.radiusBottom) ? Number(object.radiusBottom) : undefined,
+    };
+  },
+
+  toJSON(message: PBMeshRenderer_CylinderMesh): unknown {
+    const obj: any = {};
+    message.radiusTop !== undefined && (obj.radiusTop = message.radiusTop);
+    message.radiusBottom !== undefined && (obj.radiusBottom = message.radiusBottom);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PBMeshRenderer_CylinderMesh>, I>>(base?: I): PBMeshRenderer_CylinderMesh {
+    return PBMeshRenderer_CylinderMesh.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PBMeshRenderer_CylinderMesh>, I>>(object: I): PBMeshRenderer_CylinderMesh {
+    const message = createBasePBMeshRenderer_CylinderMesh();
+    message.radiusTop = object.radiusTop ?? undefined;
+    message.radiusBottom = object.radiusBottom ?? undefined;
+    return message;
+  },
+};
+
+function createBasePBMeshRenderer_PlaneMesh(): PBMeshRenderer_PlaneMesh {
+  return { uvs: [] };
+}
+
+export const PBMeshRenderer_PlaneMesh = {
+  encode(message: PBMeshRenderer_PlaneMesh, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    writer.uint32(10).fork();
+    for (const v of message.uvs) {
+      writer.float(v);
+    }
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_PlaneMesh {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBMeshRenderer_PlaneMesh();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.uvs.push(reader.float());
+            }
+          } else {
+            message.uvs.push(reader.float());
+          }
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PBMeshRenderer_PlaneMesh {
+    return { uvs: Array.isArray(object?.uvs) ? object.uvs.map((e: any) => Number(e)) : [] };
+  },
+
+  toJSON(message: PBMeshRenderer_PlaneMesh): unknown {
+    const obj: any = {};
+    if (message.uvs) {
+      obj.uvs = message.uvs.map((e) => e);
+    } else {
+      obj.uvs = [];
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PBMeshRenderer_PlaneMesh>, I>>(base?: I): PBMeshRenderer_PlaneMesh {
+    return PBMeshRenderer_PlaneMesh.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PBMeshRenderer_PlaneMesh>, I>>(object: I): PBMeshRenderer_PlaneMesh {
+    const message = createBasePBMeshRenderer_PlaneMesh();
+    message.uvs = object.uvs?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBasePBMeshRenderer_SphereMesh(): PBMeshRenderer_SphereMesh {
+  return {};
+}
+
+export const PBMeshRenderer_SphereMesh = {
+  encode(_: PBMeshRenderer_SphereMesh, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_SphereMesh {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBMeshRenderer_SphereMesh();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): PBMeshRenderer_SphereMesh {
+    return {};
+  },
+
+  toJSON(_: PBMeshRenderer_SphereMesh): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PBMeshRenderer_SphereMesh>, I>>(base?: I): PBMeshRenderer_SphereMesh {
+    return PBMeshRenderer_SphereMesh.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PBMeshRenderer_SphereMesh>, I>>(_: I): PBMeshRenderer_SphereMesh {
+    const message = createBasePBMeshRenderer_SphereMesh();
+    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/nft_shape.gen.ts

@@ -0,0 +1,275 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { Color3 } from "../../common/colors.gen";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/** NftFrameType is a predefined framing style for the image. */
+export enum NftFrameType {
+  NFT_CLASSIC = 0,
+  NFT_BAROQUE_ORNAMENT = 1,
+  NFT_DIAMOND_ORNAMENT = 2,
+  NFT_MINIMAL_WIDE = 3,
+  NFT_MINIMAL_GREY = 4,
+  NFT_BLOCKY = 5,
+  NFT_GOLD_EDGES = 6,
+  NFT_GOLD_CARVED = 7,
+  NFT_GOLD_WIDE = 8,
+  NFT_GOLD_ROUNDED = 9,
+  NFT_METAL_MEDIUM = 10,
+  NFT_METAL_WIDE = 11,
+  NFT_METAL_SLIM = 12,
+  NFT_METAL_ROUNDED = 13,
+  NFT_PINS = 14,
+  NFT_MINIMAL_BLACK = 15,
+  NFT_MINIMAL_WHITE = 16,
+  NFT_TAPE = 17,
+  NFT_WOOD_SLIM = 18,
+  NFT_WOOD_WIDE = 19,
+  NFT_WOOD_TWIGS = 20,
+  NFT_CANVAS = 21,
+  NFT_NONE = 22,
+  UNRECOGNIZED = -1,
+}
+
+export function nftFrameTypeFromJSON(object: any): NftFrameType {
+  switch (object) {
+    case 0:
+    case "NFT_CLASSIC":
+      return NftFrameType.NFT_CLASSIC;
+    case 1:
+    case "NFT_BAROQUE_ORNAMENT":
+      return NftFrameType.NFT_BAROQUE_ORNAMENT;
+    case 2:
+    case "NFT_DIAMOND_ORNAMENT":
+      return NftFrameType.NFT_DIAMOND_ORNAMENT;
+    case 3:
+    case "NFT_MINIMAL_WIDE":
+      return NftFrameType.NFT_MINIMAL_WIDE;
+    case 4:
+    case "NFT_MINIMAL_GREY":
+      return NftFrameType.NFT_MINIMAL_GREY;
+    case 5:
+    case "NFT_BLOCKY":
+      return NftFrameType.NFT_BLOCKY;
+    case 6:
+    case "NFT_GOLD_EDGES":
+      return NftFrameType.NFT_GOLD_EDGES;
+    case 7:
+    case "NFT_GOLD_CARVED":
+      return NftFrameType.NFT_GOLD_CARVED;
+    case 8:
+    case "NFT_GOLD_WIDE":
+      return NftFrameType.NFT_GOLD_WIDE;
+    case 9:
+    case "NFT_GOLD_ROUNDED":
+      return NftFrameType.NFT_GOLD_ROUNDED;
+    case 10:
+    case "NFT_METAL_MEDIUM":
+      return NftFrameType.NFT_METAL_MEDIUM;
+    case 11:
+    case "NFT_METAL_WIDE":
+      return NftFrameType.NFT_METAL_WIDE;
+    case 12:
+    case "NFT_METAL_SLIM":
+      return NftFrameType.NFT_METAL_SLIM;
+    case 13:
+    case "NFT_METAL_ROUNDED":
+      return NftFrameType.NFT_METAL_ROUNDED;
+    case 14:
+    case "NFT_PINS":
+      return NftFrameType.NFT_PINS;
+    case 15:
+    case "NFT_MINIMAL_BLACK":
+      return NftFrameType.NFT_MINIMAL_BLACK;
+    case 16:
+    case "NFT_MINIMAL_WHITE":
+      return NftFrameType.NFT_MINIMAL_WHITE;
+    case 17:
+    case "NFT_TAPE":
+      return NftFrameType.NFT_TAPE;
+    case 18:
+    case "NFT_WOOD_SLIM":
+      return NftFrameType.NFT_WOOD_SLIM;
+    case 19:
+    case "NFT_WOOD_WIDE":
+      return NftFrameType.NFT_WOOD_WIDE;
+    case 20:
+    case "NFT_WOOD_TWIGS":
+      return NftFrameType.NFT_WOOD_TWIGS;
+    case 21:
+    case "NFT_CANVAS":
+      return NftFrameType.NFT_CANVAS;
+    case 22:
+    case "NFT_NONE":
+      return NftFrameType.NFT_NONE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return NftFrameType.UNRECOGNIZED;
+  }
+}
+
+export function nftFrameTypeToJSON(object: NftFrameType): string {
+  switch (object) {
+    case NftFrameType.NFT_CLASSIC:
+      return "NFT_CLASSIC";
+    case NftFrameType.NFT_BAROQUE_ORNAMENT:
+      return "NFT_BAROQUE_ORNAMENT";
+    case NftFrameType.NFT_DIAMOND_ORNAMENT:
+      return "NFT_DIAMOND_ORNAMENT";
+    case NftFrameType.NFT_MINIMAL_WIDE:
+      return "NFT_MINIMAL_WIDE";
+    case NftFrameType.NFT_MINIMAL_GREY:
+      return "NFT_MINIMAL_GREY";
+    case NftFrameType.NFT_BLOCKY:
+      return "NFT_BLOCKY";
+    case NftFrameType.NFT_GOLD_EDGES:
+      return "NFT_GOLD_EDGES";
+    case NftFrameType.NFT_GOLD_CARVED:
+      return "NFT_GOLD_CARVED";
+    case NftFrameType.NFT_GOLD_WIDE:
+      return "NFT_GOLD_WIDE";
+    case NftFrameType.NFT_GOLD_ROUNDED:
+      return "NFT_GOLD_ROUNDED";
+    case NftFrameType.NFT_METAL_MEDIUM:
+      return "NFT_METAL_MEDIUM";
+    case NftFrameType.NFT_METAL_WIDE:
+      return "NFT_METAL_WIDE";
+    case NftFrameType.NFT_METAL_SLIM:
+      return "NFT_METAL_SLIM";
+    case NftFrameType.NFT_METAL_ROUNDED:
+      return "NFT_METAL_ROUNDED";
+    case NftFrameType.NFT_PINS:
+      return "NFT_PINS";
+    case NftFrameType.NFT_MINIMAL_BLACK:
+      return "NFT_MINIMAL_BLACK";
+    case NftFrameType.NFT_MINIMAL_WHITE:
+      return "NFT_MINIMAL_WHITE";
+    case NftFrameType.NFT_TAPE:
+      return "NFT_TAPE";
+    case NftFrameType.NFT_WOOD_SLIM:
+      return "NFT_WOOD_SLIM";
+    case NftFrameType.NFT_WOOD_WIDE:
+      return "NFT_WOOD_WIDE";
+    case NftFrameType.NFT_WOOD_TWIGS:
+      return "NFT_WOOD_TWIGS";
+    case NftFrameType.NFT_CANVAS:
+      return "NFT_CANVAS";
+    case NftFrameType.NFT_NONE:
+      return "NFT_NONE";
+    case NftFrameType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/**
+ * The NftShape component renders a framed picture from an NFT. It supports PNG, JPEG and GIF files.
+ *
+ * The `src` field is the URI of the NFT, which includes its parent contract and index, using
+ * the `https:` or `ethereum:` schemes.
+ *
+ * The picture frame can have several different styles, plus a background color for images that have
+ * transparent pixels.
+ */
+export interface PBNftShape {
+  /** the URI of the NFT */
+  src: string;
+  /** the frame style (default NFT_CLASSIC) */
+  style?:
+    | NftFrameType
+    | undefined;
+  /** RGB background (default [0.6404918, 0.611472, 0.8584906]) */
+  color?: Color3 | undefined;
+}
+
+function createBasePBNftShape(): PBNftShape {
+  return { src: "", style: undefined, color: undefined };
+}
+
+export const PBNftShape = {
+  encode(message: PBNftShape, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.src !== "") {
+      writer.uint32(10).string(message.src);
+    }
+    if (message.style !== undefined) {
+      writer.uint32(16).int32(message.style);
+    }
+    if (message.color !== undefined) {
+      Color3.encode(message.color, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PBNftShape {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBNftShape();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.src = reader.string();
+          break;
+        case 2:
+          message.style = reader.int32() as any;
+          break;
+        case 3:
+          message.color = Color3.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PBNftShape {
+    return {
+      src: isSet(object.src) ? String(object.src) : "",
+      style: isSet(object.style) ? nftFrameTypeFromJSON(object.style) : undefined,
+      color: isSet(object.color) ? Color3.fromJSON(object.color) : undefined,
+    };
+  },
+
+  toJSON(message: PBNftShape): unknown {
+    const obj: any = {};
+    message.src !== undefined && (obj.src = message.src);
+    message.style !== undefined &&
+      (obj.style = message.style !== undefined ? nftFrameTypeToJSON(message.style) : undefined);
+    message.color !== undefined && (obj.color = message.color ? Color3.toJSON(message.color) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PBNftShape>, I>>(base?: I): PBNftShape {
+    return PBNftShape.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PBNftShape>, I>>(object: I): PBNftShape {
+    const message = createBasePBNftShape();
+    message.src = object.src ?? "";
+    message.style = object.style ?? undefined;
+    message.color = (object.color !== undefined && object.color !== null)
+      ? Color3.fromPartial(object.color)
+      : 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;
+}