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

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

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBAvatarAttach = exports.AvatarAnchorPointType = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const protobufPackageSarasa = "decentraland.sdk.components";
+/** AvatarAnchorPointType determines the part of the avatar's body that anchors the Entity. */
+/**
+ * @public
+ */
+var AvatarAnchorPointType;
+(function (AvatarAnchorPointType) {
+    AvatarAnchorPointType[AvatarAnchorPointType["AAPT_POSITION"] = 0] = "AAPT_POSITION";
+    AvatarAnchorPointType[AvatarAnchorPointType["AAPT_NAME_TAG"] = 1] = "AAPT_NAME_TAG";
+    AvatarAnchorPointType[AvatarAnchorPointType["AAPT_LEFT_HAND"] = 2] = "AAPT_LEFT_HAND";
+    AvatarAnchorPointType[AvatarAnchorPointType["AAPT_RIGHT_HAND"] = 3] = "AAPT_RIGHT_HAND";
+})(AvatarAnchorPointType = exports.AvatarAnchorPointType || (exports.AvatarAnchorPointType = {}));
+function createBasePBAvatarAttach() {
+    return { avatarId: undefined, anchorPointId: 0 };
+}
+/**
+ * @public
+ */
+var PBAvatarAttach;
+(function (PBAvatarAttach) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.avatarId !== undefined) {
+            writer.uint32(10).string(message.avatarId);
+        }
+        if (message.anchorPointId !== 0) {
+            writer.uint32(16).int32(message.anchorPointId);
+        }
+        return writer;
+    }
+    PBAvatarAttach.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 = 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();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBAvatarAttach.decode = decode;
+})(PBAvatarAttach = exports.PBAvatarAttach || (exports.PBAvatarAttach = {}));

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

@@ -0,0 +1,44 @@
+import _m0 from "protobufjs/minimal";
+import { Vector3 } from "../../common/vectors.gen";
+/** AvatarModifierType is an effect that should be applied to avatars inside the region. */
+/**
+ * @public
+ */
+export declare const enum AvatarModifierType {
+    /** AMT_HIDE_AVATARS - avatars are invisible */
+    AMT_HIDE_AVATARS = 0,
+    /** AMT_DISABLE_PASSPORTS - selecting (e.g. clicking) an avatar will not bring up their profile. */
+    AMT_DISABLE_PASSPORTS = 1
+}
+/**
+ * The AvatarModifierArea component can be attached to an Entity to define a region of space where
+ * avatar behavior changes.
+ *
+ * The Entity's Transform position determines the center-point of the region, while its size is
+ * given as a vector in the `area` property below. The Transform rotation is applied, but the scale
+ * is ignored.
+ *
+ * The modifier effect is only applied to avatars inside the region. It does not affect how players
+ * standing inside it see avatars on the other side of the boundary.
+ *
+ * Note that, while commonly used to delineate a 2D area in a scene (hence the name), the region
+ * is actually a 3D volume.
+ */
+/**
+ * @public
+ */
+export interface PBAvatarModifierArea {
+    /** the 3D size of the region */
+    area: Vector3 | undefined;
+    /** user IDs that can enter and remain unaffected */
+    excludeIds: string[];
+    /** list of modifiers to apply */
+    modifiers: AvatarModifierType[];
+}
+/**
+ * @public
+ */
+export declare namespace PBAvatarModifierArea {
+    function encode(message: PBAvatarModifierArea, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarModifierArea;
+}

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

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBAvatarModifierArea = exports.AvatarModifierType = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const vectors_gen_1 = require("../../common/vectors.gen");
+const protobufPackageSarasa = "decentraland.sdk.components";
+/** AvatarModifierType is an effect that should be applied to avatars inside the region. */
+/**
+ * @public
+ */
+var AvatarModifierType;
+(function (AvatarModifierType) {
+    /** AMT_HIDE_AVATARS - avatars are invisible */
+    AvatarModifierType[AvatarModifierType["AMT_HIDE_AVATARS"] = 0] = "AMT_HIDE_AVATARS";
+    /** AMT_DISABLE_PASSPORTS - selecting (e.g. clicking) an avatar will not bring up their profile. */
+    AvatarModifierType[AvatarModifierType["AMT_DISABLE_PASSPORTS"] = 1] = "AMT_DISABLE_PASSPORTS";
+})(AvatarModifierType = exports.AvatarModifierType || (exports.AvatarModifierType = {}));
+function createBasePBAvatarModifierArea() {
+    return { area: undefined, excludeIds: [], modifiers: [] };
+}
+/**
+ * @public
+ */
+var PBAvatarModifierArea;
+(function (PBAvatarModifierArea) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.area !== undefined) {
+            vectors_gen_1.Vector3.encode(message.area, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.excludeIds) {
+            writer.uint32(18).string(v);
+        }
+        writer.uint32(26).fork();
+        for (const v of message.modifiers) {
+            writer.int32(v);
+        }
+        writer.ldelim();
+        return writer;
+    }
+    PBAvatarModifierArea.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 = createBasePBAvatarModifierArea();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.area = vectors_gen_1.Vector3.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.excludeIds.push(reader.string());
+                    continue;
+                case 3:
+                    if (tag === 24) {
+                        message.modifiers.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 26) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.modifiers.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBAvatarModifierArea.decode = decode;
+})(PBAvatarModifierArea = exports.PBAvatarModifierArea || (exports.PBAvatarModifierArea = {}));

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

@@ -0,0 +1,56 @@
+import _m0 from "protobufjs/minimal";
+import { Color3 } from "../../common/colors.gen";
+/**
+ * The AvatarShape component contains the information required to draw and animate avatar, acting as
+ * a simplified GLTF container for this specific case.
+ *
+ * All fields (except ID) are optional have reasonable default values. In the case of `wearables`,
+ * each slot on the Avatar's body that is not explicitly included in the list has its own default.
+ *
+ * Note that, while AvatarShape can be attached to any Entity, it's only actually used in the global
+ * Avatar Scene. Other requirements are usually better served by GLTFs.
+ */
+/**
+ * @public
+ */
+export interface PBAvatarShape {
+    /** the user ID */
+    id: string;
+    /** visible name (default: "NPC") */
+    name?: string | undefined;
+    /** shape URN (default "urn:decentraland:off-chain:base-avatars:BaseFemale") */
+    bodyShape?: string | undefined;
+    /** RGB (default [0.6, 0.462, 0.356]) */
+    skinColor?: Color3 | undefined;
+    /** RGB (default [0.283, 0.142, 0]) */
+    hairColor?: Color3 | undefined;
+    /** RGB (default [0.6, 0.462, 0.356]) */
+    eyeColor?: Color3 | undefined;
+    /** current emote animations */
+    expressionTriggerId?: string | undefined;
+    /** start of emote animations (in the same order) */
+    expressionTriggerTimestamp?: number | undefined;
+    /** whether to display the floating voice chat icon */
+    talking?: boolean | undefined;
+    /**
+     * Wearable URNs, one for each body slot.
+     *   Default values for each unspecified slot:
+     *     Eyes    : "urn:decentraland:off-chain:base-avatars:f_eyes_00",
+     *     Eyebrows: "urn:decentraland:off-chain:base-avatars:f_eyebrows_00",
+     *     Mouth   : "urn:decentraland:off-chain:base-avatars:f_mouth_00"
+     *     Hair    : "urn:decentraland:off-chain:base-avatars:standard_hair",
+     *     Shirt   : "urn:decentraland:off-chain:base-avatars:f_simple_yellow_tshirt",
+     *     Trousers: "urn:decentraland:off-chain:base-avatars:f_brown_trousers",
+     *     Shoes   : "urn:decentraland:off-chain:base-avatars:bun_shoes"]
+     */
+    wearables: string[];
+    /** available emotes (default empty) */
+    emotes: string[];
+}
+/**
+ * @public
+ */
+export declare namespace PBAvatarShape {
+    function encode(message: PBAvatarShape, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarShape;
+}

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

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBAvatarShape = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const colors_gen_1 = require("../../common/colors.gen");
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBAvatarShape() {
+    return {
+        id: "",
+        name: undefined,
+        bodyShape: undefined,
+        skinColor: undefined,
+        hairColor: undefined,
+        eyeColor: undefined,
+        expressionTriggerId: undefined,
+        expressionTriggerTimestamp: undefined,
+        talking: undefined,
+        wearables: [],
+        emotes: [],
+    };
+}
+/**
+ * @public
+ */
+var PBAvatarShape;
+(function (PBAvatarShape) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        if (message.name !== undefined) {
+            writer.uint32(18).string(message.name);
+        }
+        if (message.bodyShape !== undefined) {
+            writer.uint32(26).string(message.bodyShape);
+        }
+        if (message.skinColor !== undefined) {
+            colors_gen_1.Color3.encode(message.skinColor, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.hairColor !== undefined) {
+            colors_gen_1.Color3.encode(message.hairColor, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.eyeColor !== undefined) {
+            colors_gen_1.Color3.encode(message.eyeColor, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.expressionTriggerId !== undefined) {
+            writer.uint32(58).string(message.expressionTriggerId);
+        }
+        if (message.expressionTriggerTimestamp !== undefined) {
+            writer.uint32(64).int64(message.expressionTriggerTimestamp);
+        }
+        if (message.talking !== undefined) {
+            writer.uint32(72).bool(message.talking);
+        }
+        for (const v of message.wearables) {
+            writer.uint32(82).string(v);
+        }
+        for (const v of message.emotes) {
+            writer.uint32(90).string(v);
+        }
+        return writer;
+    }
+    PBAvatarShape.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 = createBasePBAvatarShape();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.id = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.bodyShape = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.skinColor = colors_gen_1.Color3.decode(reader, reader.uint32());
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.hairColor = colors_gen_1.Color3.decode(reader, reader.uint32());
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.eyeColor = colors_gen_1.Color3.decode(reader, reader.uint32());
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.expressionTriggerId = reader.string();
+                    continue;
+                case 8:
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.expressionTriggerTimestamp = longToNumber(reader.int64());
+                    continue;
+                case 9:
+                    if (tag !== 72) {
+                        break;
+                    }
+                    message.talking = reader.bool();
+                    continue;
+                case 10:
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.wearables.push(reader.string());
+                    continue;
+                case 11:
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.emotes.push(reader.string());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBAvatarShape.decode = decode;
+})(PBAvatarShape = exports.PBAvatarShape || (exports.PBAvatarShape = {}));
+var tsProtoGlobalThis = (() => {
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    throw "Unable to locate global object";
+})();
+function longToNumber(long) {
+    if (long.gt(Number.MAX_SAFE_INTEGER)) {
+        throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    return long.toNumber();
+}
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

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

@@ -0,0 +1,38 @@
+import _m0 from "protobufjs/minimal";
+/**
+ * BillboardMode indicates one or more axis for automatic rotation, in OR-able bit flag form.
+ * Only the values below and the (BM_X | BM_Y) combination are valid.
+ */
+/**
+ * @public
+ */
+export declare const enum BillboardMode {
+    BM_NONE = 0,
+    BM_X = 1,
+    BM_Y = 2,
+    BM_Z = 4,
+    /** BM_ALL - bitwise combination BM_X | BM_Y | BM_Z */
+    BM_ALL = 7
+}
+/**
+ * The Billboard component makes an Entity automatically reorient its rotation to face the camera.
+ * As the name indicates, it’s used to display in-game billboards and frequently combined with
+ * the TextShape component.
+ *
+ * Billboard only affects the Entity's rotation. Its scale and position are still determined by its
+ * Transform.
+ */
+/**
+ * @public
+ */
+export interface PBBillboard {
+    /** the BillboardMode (default: BM_ALL) */
+    billboardMode?: BillboardMode | undefined;
+}
+/**
+ * @public
+ */
+export declare namespace PBBillboard {
+    function encode(message: PBBillboard, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBBillboard;
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBBillboard = exports.BillboardMode = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const protobufPackageSarasa = "decentraland.sdk.components";
+/**
+ * BillboardMode indicates one or more axis for automatic rotation, in OR-able bit flag form.
+ * Only the values below and the (BM_X | BM_Y) combination are valid.
+ */
+/**
+ * @public
+ */
+var BillboardMode;
+(function (BillboardMode) {
+    BillboardMode[BillboardMode["BM_NONE"] = 0] = "BM_NONE";
+    BillboardMode[BillboardMode["BM_X"] = 1] = "BM_X";
+    BillboardMode[BillboardMode["BM_Y"] = 2] = "BM_Y";
+    BillboardMode[BillboardMode["BM_Z"] = 4] = "BM_Z";
+    /** BM_ALL - bitwise combination BM_X | BM_Y | BM_Z */
+    BillboardMode[BillboardMode["BM_ALL"] = 7] = "BM_ALL";
+})(BillboardMode = exports.BillboardMode || (exports.BillboardMode = {}));
+function createBasePBBillboard() {
+    return { billboardMode: undefined };
+}
+/**
+ * @public
+ */
+var PBBillboard;
+(function (PBBillboard) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.billboardMode !== undefined) {
+            writer.uint32(8).int32(message.billboardMode);
+        }
+        return writer;
+    }
+    PBBillboard.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 = createBasePBBillboard();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.billboardMode = reader.int32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBBillboard.decode = decode;
+})(PBBillboard = exports.PBBillboard || (exports.PBBillboard = {}));

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

@@ -0,0 +1,20 @@
+import _m0 from "protobufjs/minimal";
+import { CameraType } from "./common/camera_type.gen";
+/**
+ * The CameraMode component can be used to determine whether the player is using a first-person o
+ * third-person view.
+ */
+/**
+ * @public
+ */
+export interface PBCameraMode {
+    /** the camera type (1st-person or 3rd-person) */
+    mode: CameraType;
+}
+/**
+ * @public
+ */
+export declare namespace PBCameraMode {
+    function encode(message: PBCameraMode, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBCameraMode;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBCameraMode = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBCameraMode() {
+    return { mode: 0 };
+}
+/**
+ * @public
+ */
+var PBCameraMode;
+(function (PBCameraMode) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.mode !== 0) {
+            writer.uint32(8).int32(message.mode);
+        }
+        return writer;
+    }
+    PBCameraMode.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 = createBasePBCameraMode();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.mode = reader.int32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBCameraMode.decode = decode;
+})(PBCameraMode = exports.PBCameraMode || (exports.PBCameraMode = {}));

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

@@ -0,0 +1,32 @@
+import _m0 from "protobufjs/minimal";
+import { Vector3 } from "../../common/vectors.gen";
+import { CameraType } from "./common/camera_type.gen";
+/**
+ * The CameraModeArea component can be attached to an Entity to define a region of space where
+ * the player's camera mode (1st-person or 3rd-person) is overridden.
+ *
+ * The Entity's Transform position determines the center-point of the region, while its size is
+ * given as a vector in the `area` property below. The Transform rotation is applied, but the scale
+ * is ignored.
+ *
+ * When players leave the region, their previous setting is restored.
+ *
+ * Note that, while commonly used to delineate a 2D area in a scene (hence the name), the region
+ * is actually a 3D volume.
+ */
+/**
+ * @public
+ */
+export interface PBCameraModeArea {
+    /** the 3D size of the region */
+    area: Vector3 | undefined;
+    /** the camera mode to enforce */
+    mode: CameraType;
+}
+/**
+ * @public
+ */
+export declare namespace PBCameraModeArea {
+    function encode(message: PBCameraModeArea, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBCameraModeArea;
+}