@dcl/ecs 7.1.12-4982571416.commit-0b87aa7 → 7.1.12-4983011170.commit-adaaaa2

package/dist-cjs/components/generated/pb/decentraland/sdk/components/mesh_collider.gen.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBMeshCollider_SphereMesh = exports.PBMeshCollider_PlaneMesh = exports.PBMeshCollider_CylinderMesh = exports.PBMeshCollider_BoxMesh = exports.PBMeshCollider = exports.ColliderLayer = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const protobufPackageSarasa = "decentraland.sdk.components";
+/** ColliderLayer determines the kind of collision to detect, in OR-able bit flag form. */
+/**
+ * @public
+ */
+var ColliderLayer;
+(function (ColliderLayer) {
+    /** CL_NONE - no collisions */
+    ColliderLayer[ColliderLayer["CL_NONE"] = 0] = "CL_NONE";
+    /** CL_POINTER - collisions with the player's pointer ray (e.g. mouse cursor hovering) */
+    ColliderLayer[ColliderLayer["CL_POINTER"] = 1] = "CL_POINTER";
+    /** CL_PHYSICS - collision affecting your player's physics i.e. walls, floor, moving platfroms */
+    ColliderLayer[ColliderLayer["CL_PHYSICS"] = 2] = "CL_PHYSICS";
+    ColliderLayer[ColliderLayer["CL_RESERVED1"] = 4] = "CL_RESERVED1";
+    ColliderLayer[ColliderLayer["CL_RESERVED2"] = 8] = "CL_RESERVED2";
+    ColliderLayer[ColliderLayer["CL_RESERVED3"] = 16] = "CL_RESERVED3";
+    ColliderLayer[ColliderLayer["CL_RESERVED4"] = 32] = "CL_RESERVED4";
+    ColliderLayer[ColliderLayer["CL_RESERVED5"] = 64] = "CL_RESERVED5";
+    ColliderLayer[ColliderLayer["CL_RESERVED6"] = 128] = "CL_RESERVED6";
+    ColliderLayer[ColliderLayer["CL_CUSTOM1"] = 256] = "CL_CUSTOM1";
+    ColliderLayer[ColliderLayer["CL_CUSTOM2"] = 512] = "CL_CUSTOM2";
+    ColliderLayer[ColliderLayer["CL_CUSTOM3"] = 1024] = "CL_CUSTOM3";
+    ColliderLayer[ColliderLayer["CL_CUSTOM4"] = 2048] = "CL_CUSTOM4";
+    ColliderLayer[ColliderLayer["CL_CUSTOM5"] = 4096] = "CL_CUSTOM5";
+    ColliderLayer[ColliderLayer["CL_CUSTOM6"] = 8192] = "CL_CUSTOM6";
+    ColliderLayer[ColliderLayer["CL_CUSTOM7"] = 16384] = "CL_CUSTOM7";
+    ColliderLayer[ColliderLayer["CL_CUSTOM8"] = 32768] = "CL_CUSTOM8";
+})(ColliderLayer = exports.ColliderLayer || (exports.ColliderLayer = {}));
+function createBasePBMeshCollider() {
+    return { collisionMask: undefined, mesh: undefined };
+}
+/**
+ * @public
+ */
+var PBMeshCollider;
+(function (PBMeshCollider) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.collisionMask !== undefined) {
+            writer.uint32(8).uint32(message.collisionMask);
+        }
+        switch (message.mesh?.$case) {
+            case "box":
+                PBMeshCollider_BoxMesh.encode(message.mesh.box, writer.uint32(18).fork()).ldelim();
+                break;
+            case "sphere":
+                PBMeshCollider_SphereMesh.encode(message.mesh.sphere, writer.uint32(26).fork()).ldelim();
+                break;
+            case "cylinder":
+                PBMeshCollider_CylinderMesh.encode(message.mesh.cylinder, writer.uint32(34).fork()).ldelim();
+                break;
+            case "plane":
+                PBMeshCollider_PlaneMesh.encode(message.mesh.plane, writer.uint32(42).fork()).ldelim();
+                break;
+        }
+        return writer;
+    }
+    PBMeshCollider.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMeshCollider();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.collisionMask = reader.uint32();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.mesh = { $case: "box", box: PBMeshCollider_BoxMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.mesh = { $case: "sphere", sphere: PBMeshCollider_SphereMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.mesh = { $case: "cylinder", cylinder: PBMeshCollider_CylinderMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.mesh = { $case: "plane", plane: PBMeshCollider_PlaneMesh.decode(reader, reader.uint32()) };
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshCollider.decode = decode;
+})(PBMeshCollider = exports.PBMeshCollider || (exports.PBMeshCollider = {}));
+function createBasePBMeshCollider_BoxMesh() {
+    return {};
+}
+/**
+ * @public
+ */
+var PBMeshCollider_BoxMesh;
+(function (PBMeshCollider_BoxMesh) {
+    function encode(_, writer = minimal_1.default.Writer.create()) {
+        return writer;
+    }
+    PBMeshCollider_BoxMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMeshCollider_BoxMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshCollider_BoxMesh.decode = decode;
+})(PBMeshCollider_BoxMesh = exports.PBMeshCollider_BoxMesh || (exports.PBMeshCollider_BoxMesh = {}));
+function createBasePBMeshCollider_CylinderMesh() {
+    return { radiusTop: undefined, radiusBottom: undefined };
+}
+/**
+ * @public
+ */
+var PBMeshCollider_CylinderMesh;
+(function (PBMeshCollider_CylinderMesh) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.radiusTop !== undefined) {
+            writer.uint32(13).float(message.radiusTop);
+        }
+        if (message.radiusBottom !== undefined) {
+            writer.uint32(21).float(message.radiusBottom);
+        }
+        return writer;
+    }
+    PBMeshCollider_CylinderMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMeshCollider_CylinderMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.radiusTop = reader.float();
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.radiusBottom = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshCollider_CylinderMesh.decode = decode;
+})(PBMeshCollider_CylinderMesh = exports.PBMeshCollider_CylinderMesh || (exports.PBMeshCollider_CylinderMesh = {}));
+function createBasePBMeshCollider_PlaneMesh() {
+    return {};
+}
+/**
+ * @public
+ */
+var PBMeshCollider_PlaneMesh;
+(function (PBMeshCollider_PlaneMesh) {
+    function encode(_, writer = minimal_1.default.Writer.create()) {
+        return writer;
+    }
+    PBMeshCollider_PlaneMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMeshCollider_PlaneMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshCollider_PlaneMesh.decode = decode;
+})(PBMeshCollider_PlaneMesh = exports.PBMeshCollider_PlaneMesh || (exports.PBMeshCollider_PlaneMesh = {}));
+function createBasePBMeshCollider_SphereMesh() {
+    return {};
+}
+/**
+ * @public
+ */
+var PBMeshCollider_SphereMesh;
+(function (PBMeshCollider_SphereMesh) {
+    function encode(_, writer = minimal_1.default.Writer.create()) {
+        return writer;
+    }
+    PBMeshCollider_SphereMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMeshCollider_SphereMesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshCollider_SphereMesh.decode = decode;
+})(PBMeshCollider_SphereMesh = exports.PBMeshCollider_SphereMesh || (exports.PBMeshCollider_SphereMesh = {}));

package/dist-cjs/components/generated/pb/decentraland/sdk/components/mesh_renderer.gen.d.ts

@@ -0,0 +1,96 @@
+import _m0 from "protobufjs/minimal";
+/**
+ * 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.
+ */
+/**
+ * @public
+ */
+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. */
+/**
+ * @public
+ */
+export interface PBMeshRenderer_BoxMesh {
+    /** 96-value texture map (2D * 6 faces * 2 sides * 4 vertices) */
+    uvs: number[];
+}
+/** CylinderMesh renders a truncated cone shape. */
+/**
+ * @public
+ */
+export interface PBMeshRenderer_CylinderMesh {
+    /** (default 0.5) */
+    radiusTop?: number | undefined;
+    /** (default 0.5) */
+    radiusBottom?: number | undefined;
+}
+/** PlaneMesh renders a 2D rectangular shape. */
+/**
+ * @public
+ */
+export interface PBMeshRenderer_PlaneMesh {
+    /** 16-value texture map (2D * 1 face * 2 sides * 4 vertices) */
+    uvs: number[];
+}
+/** SphereMesh renders a spherical shape. */
+/**
+ * @public
+ */
+export interface PBMeshRenderer_SphereMesh {
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshRenderer {
+    function encode(message: PBMeshRenderer, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshRenderer_BoxMesh {
+    function encode(message: PBMeshRenderer_BoxMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_BoxMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshRenderer_CylinderMesh {
+    function encode(message: PBMeshRenderer_CylinderMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_CylinderMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshRenderer_PlaneMesh {
+    function encode(message: PBMeshRenderer_PlaneMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_PlaneMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshRenderer_SphereMesh {
+    function encode(_: PBMeshRenderer_SphereMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_SphereMesh;
+}

package/dist-cjs/components/generated/pb/decentraland/sdk/components/mesh_renderer.gen.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBMeshRenderer_SphereMesh = exports.PBMeshRenderer_PlaneMesh = exports.PBMeshRenderer_CylinderMesh = exports.PBMeshRenderer_BoxMesh = exports.PBMeshRenderer = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBMeshRenderer() {
+    return { mesh: undefined };
+}
+/**
+ * @public
+ */
+var PBMeshRenderer;
+(function (PBMeshRenderer) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        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;
+    }
+    PBMeshRenderer.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(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:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.mesh = { $case: "box", box: PBMeshRenderer_BoxMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.mesh = { $case: "sphere", sphere: PBMeshRenderer_SphereMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.mesh = { $case: "cylinder", cylinder: PBMeshRenderer_CylinderMesh.decode(reader, reader.uint32()) };
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.mesh = { $case: "plane", plane: PBMeshRenderer_PlaneMesh.decode(reader, reader.uint32()) };
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshRenderer.decode = decode;
+})(PBMeshRenderer = exports.PBMeshRenderer || (exports.PBMeshRenderer = {}));
+function createBasePBMeshRenderer_BoxMesh() {
+    return { uvs: [] };
+}
+/**
+ * @public
+ */
+var PBMeshRenderer_BoxMesh;
+(function (PBMeshRenderer_BoxMesh) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        writer.uint32(10).fork();
+        for (const v of message.uvs) {
+            writer.float(v);
+        }
+        writer.ldelim();
+        return writer;
+    }
+    PBMeshRenderer_BoxMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(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 === 13) {
+                        message.uvs.push(reader.float());
+                        continue;
+                    }
+                    if (tag === 10) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.uvs.push(reader.float());
+                        }
+                        continue;
+                    }
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshRenderer_BoxMesh.decode = decode;
+})(PBMeshRenderer_BoxMesh = exports.PBMeshRenderer_BoxMesh || (exports.PBMeshRenderer_BoxMesh = {}));
+function createBasePBMeshRenderer_CylinderMesh() {
+    return { radiusTop: undefined, radiusBottom: undefined };
+}
+/**
+ * @public
+ */
+var PBMeshRenderer_CylinderMesh;
+(function (PBMeshRenderer_CylinderMesh) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.radiusTop !== undefined) {
+            writer.uint32(13).float(message.radiusTop);
+        }
+        if (message.radiusBottom !== undefined) {
+            writer.uint32(21).float(message.radiusBottom);
+        }
+        return writer;
+    }
+    PBMeshRenderer_CylinderMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(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:
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.radiusTop = reader.float();
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.radiusBottom = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshRenderer_CylinderMesh.decode = decode;
+})(PBMeshRenderer_CylinderMesh = exports.PBMeshRenderer_CylinderMesh || (exports.PBMeshRenderer_CylinderMesh = {}));
+function createBasePBMeshRenderer_PlaneMesh() {
+    return { uvs: [] };
+}
+/**
+ * @public
+ */
+var PBMeshRenderer_PlaneMesh;
+(function (PBMeshRenderer_PlaneMesh) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        writer.uint32(10).fork();
+        for (const v of message.uvs) {
+            writer.float(v);
+        }
+        writer.ldelim();
+        return writer;
+    }
+    PBMeshRenderer_PlaneMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(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 === 13) {
+                        message.uvs.push(reader.float());
+                        continue;
+                    }
+                    if (tag === 10) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.uvs.push(reader.float());
+                        }
+                        continue;
+                    }
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshRenderer_PlaneMesh.decode = decode;
+})(PBMeshRenderer_PlaneMesh = exports.PBMeshRenderer_PlaneMesh || (exports.PBMeshRenderer_PlaneMesh = {}));
+function createBasePBMeshRenderer_SphereMesh() {
+    return {};
+}
+/**
+ * @public
+ */
+var PBMeshRenderer_SphereMesh;
+(function (PBMeshRenderer_SphereMesh) {
+    function encode(_, writer = minimal_1.default.Writer.create()) {
+        return writer;
+    }
+    PBMeshRenderer_SphereMesh.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(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) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBMeshRenderer_SphereMesh.decode = decode;
+})(PBMeshRenderer_SphereMesh = exports.PBMeshRenderer_SphereMesh || (exports.PBMeshRenderer_SphereMesh = {}));

package/dist-cjs/components/generated/pb/decentraland/sdk/components/nft_shape.gen.d.ts

@@ -0,0 +1,58 @@
+import _m0 from "protobufjs/minimal";
+import { Color3 } from "../../common/colors.gen";
+/** NftFrameType is a predefined framing style for the image. */
+/**
+ * @public
+ */
+export declare const 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
+}
+/**
+ * The NftShape component renders a framed picture from an NFT. It supports PNG, JPEG and GIF files.
+ *
+ * The `urn` field is the URI of the NFT, and must follow the format 'urn:decentraland:<CHAIN>:<CONTRACT_STANDARD>:<CONTRACT_ADDRESS>:<TOKEN_ID>'
+ * Example: 'urn:decentraland:ethereum:erc721:0x00000000:123'
+ *
+ * The picture frame can have several different styles, plus a background color for images that have
+ * transparent pixels.
+ */
+/**
+ * @public
+ */
+export interface PBNftShape {
+    /** the URI of the NFT */
+    urn: string;
+    /** the frame style (default NFT_CLASSIC) */
+    style?: NftFrameType | undefined;
+    /** RGB background (default [0.6404918, 0.611472, 0.8584906]) */
+    color?: Color3 | undefined;
+}
+/**
+ * @public
+ */
+export declare namespace PBNftShape {
+    function encode(message: PBNftShape, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBNftShape;
+}