@dcl/ecs 7.0.0-3548419522.commit-ddcf4b7 → 7.0.0

package/dist/components/generated/pb/decentraland/sdk/components/animator.gen.d.ts

@@ -0,0 +1,30 @@
+import _m0 from 'protobufjs/minimal';
+export interface PBAnimator {
+    states: PBAnimationState[];
+}
+export interface PBAnimationState {
+    name: string;
+    clip: string;
+    playing?: boolean | undefined;
+    /** default=1.0s */
+    weight?: number | undefined;
+    /** default=1.0 */
+    speed?: number | undefined;
+    /** default=true */
+    loop?: boolean | undefined;
+    shouldReset?: boolean | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBAnimator: {
+    encode(message: PBAnimator, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBAnimator;
+};
+/**
+ * Internal
+ */
+export declare const PBAnimationState: {
+    encode(message: PBAnimationState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBAnimationState;
+};

package/dist/components/generated/pb/decentraland/sdk/components/animator.gen.js

@@ -0,0 +1,109 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBAnimator() {
+    return { states: [] };
+}
+/**
+ * Internal
+ */
+export const PBAnimator = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.states) {
+            PBAnimationState.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBAnimator();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.states.push(PBAnimationState.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBAnimationState() {
+    return {
+        name: '',
+        clip: '',
+        playing: undefined,
+        weight: undefined,
+        speed: undefined,
+        loop: undefined,
+        shouldReset: undefined
+    };
+}
+/**
+ * Internal
+ */
+export const PBAnimationState = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.name !== '') {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.clip !== '') {
+            writer.uint32(18).string(message.clip);
+        }
+        if (message.playing !== undefined) {
+            writer.uint32(24).bool(message.playing);
+        }
+        if (message.weight !== undefined) {
+            writer.uint32(37).float(message.weight);
+        }
+        if (message.speed !== undefined) {
+            writer.uint32(45).float(message.speed);
+        }
+        if (message.loop !== undefined) {
+            writer.uint32(48).bool(message.loop);
+        }
+        if (message.shouldReset !== undefined) {
+            writer.uint32(56).bool(message.shouldReset);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBAnimationState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.clip = reader.string();
+                    break;
+                case 3:
+                    message.playing = reader.bool();
+                    break;
+                case 4:
+                    message.weight = reader.float();
+                    break;
+                case 5:
+                    message.speed = reader.float();
+                    break;
+                case 6:
+                    message.loop = reader.bool();
+                    break;
+                case 7:
+                    message.shouldReset = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

package/dist/components/generated/pb/decentraland/sdk/components/audio_source.gen.d.ts

@@ -0,0 +1,17 @@
+import _m0 from 'protobufjs/minimal';
+export interface PBAudioSource {
+    playing?: boolean | undefined;
+    /** default=1.0f */
+    volume?: number | undefined;
+    loop?: boolean | undefined;
+    /** default=1.0f */
+    pitch?: number | undefined;
+    audioClipUrl: string;
+}
+/**
+ * Internal
+ */
+export declare const PBAudioSource: {
+    encode(message: PBAudioSource, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBAudioSource;
+};

package/dist/components/generated/pb/decentraland/sdk/components/audio_source.gen.js

@@ -0,0 +1,58 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBAudioSource() {
+    return { playing: undefined, volume: undefined, loop: undefined, pitch: undefined, audioClipUrl: '' };
+}
+/**
+ * Internal
+ */
+export const PBAudioSource = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.playing !== undefined) {
+            writer.uint32(8).bool(message.playing);
+        }
+        if (message.volume !== undefined) {
+            writer.uint32(21).float(message.volume);
+        }
+        if (message.loop !== undefined) {
+            writer.uint32(24).bool(message.loop);
+        }
+        if (message.pitch !== undefined) {
+            writer.uint32(37).float(message.pitch);
+        }
+        if (message.audioClipUrl !== '') {
+            writer.uint32(42).string(message.audioClipUrl);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBAudioSource();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.playing = reader.bool();
+                    break;
+                case 2:
+                    message.volume = reader.float();
+                    break;
+                case 3:
+                    message.loop = reader.bool();
+                    break;
+                case 4:
+                    message.pitch = reader.float();
+                    break;
+                case 5:
+                    message.audioClipUrl = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

package/dist/components/generated/pb/decentraland/sdk/components/audio_stream.gen.d.ts

@@ -0,0 +1,14 @@
+import _m0 from 'protobufjs/minimal';
+export interface PBAudioStream {
+    playing?: boolean | undefined;
+    /** default=1.0f */
+    volume?: number | undefined;
+    url: string;
+}
+/**
+ * Internal
+ */
+export declare const PBAudioStream: {
+    encode(message: PBAudioStream, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBAudioStream;
+};

package/dist/components/generated/pb/decentraland/sdk/components/audio_stream.gen.js

@@ -0,0 +1,46 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBAudioStream() {
+    return { playing: undefined, volume: undefined, url: '' };
+}
+/**
+ * Internal
+ */
+export const PBAudioStream = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.playing !== undefined) {
+            writer.uint32(8).bool(message.playing);
+        }
+        if (message.volume !== undefined) {
+            writer.uint32(21).float(message.volume);
+        }
+        if (message.url !== '') {
+            writer.uint32(26).string(message.url);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBAudioStream();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.playing = reader.bool();
+                    break;
+                case 2:
+                    message.volume = reader.float();
+                    break;
+                case 3:
+                    message.url = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

package/dist/components/generated/pb/decentraland/sdk/components/avatar_attach.gen.d.ts

@@ -0,0 +1,18 @@
+import _m0 from 'protobufjs/minimal';
+export declare const enum AvatarAnchorPointType {
+    AAPT_POSITION = 0,
+    AAPT_NAME_TAG = 1,
+    AAPT_LEFT_HAND = 2,
+    AAPT_RIGHT_HAND = 3
+}
+export interface PBAvatarAttach {
+    avatarId: string;
+    anchorPointId: AvatarAnchorPointType;
+}
+/**
+ * Internal
+ */
+export declare const PBAvatarAttach: {
+    encode(message: PBAvatarAttach, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarAttach;
+};

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

@@ -0,0 +1,47 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+export 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 || (AvatarAnchorPointType = {}));
+function createBasePBAvatarAttach() {
+    return { avatarId: '', anchorPointId: 0 };
+}
+/**
+ * Internal
+ */
+export const PBAvatarAttach = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.avatarId !== '') {
+            writer.uint32(10).string(message.avatarId);
+        }
+        if (message.anchorPointId !== 0) {
+            writer.uint32(16).int32(message.anchorPointId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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:
+                    message.avatarId = reader.string();
+                    break;
+                case 2:
+                    message.anchorPointId = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,18 @@
+import { Vector3 } from '../../common/vectors.gen';
+import _m0 from 'protobufjs/minimal';
+export declare const enum AvatarModifierType {
+    AMT_HIDE_AVATARS = 0,
+    AMT_DISABLE_PASSPORTS = 1
+}
+export interface PBAvatarModifierArea {
+    area: Vector3 | undefined;
+    excludeIds: string[];
+    modifiers: AvatarModifierType[];
+}
+/**
+ * Internal
+ */
+export declare const PBAvatarModifierArea: {
+    encode(message: PBAvatarModifierArea, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarModifierArea;
+};

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

@@ -0,0 +1,62 @@
+/* eslint-disable */
+import { Vector3 } from '../../common/vectors.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+export var AvatarModifierType;
+(function (AvatarModifierType) {
+    AvatarModifierType[AvatarModifierType["AMT_HIDE_AVATARS"] = 0] = "AMT_HIDE_AVATARS";
+    AvatarModifierType[AvatarModifierType["AMT_DISABLE_PASSPORTS"] = 1] = "AMT_DISABLE_PASSPORTS";
+})(AvatarModifierType || (AvatarModifierType = {}));
+function createBasePBAvatarModifierArea() {
+    return { area: undefined, excludeIds: [], modifiers: [] };
+}
+/**
+ * Internal
+ */
+export const PBAvatarModifierArea = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.area !== undefined) {
+            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;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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:
+                    message.area = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.excludeIds.push(reader.string());
+                    break;
+                case 3:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.modifiers.push(reader.int32());
+                        }
+                    }
+                    else {
+                        message.modifiers.push(reader.int32());
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,38 @@
+import { Color3 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+export interface PBAvatarShape {
+    id: string;
+    /** default = NPC */
+    name?: string | undefined;
+    /** default = urn:decentraland:off-chain:base-avatars:BaseFemale */
+    bodyShape?: string | undefined;
+    /** default = decentraland.common.Color3(R = 0.6f, G = 0.462f, B = 0.356f) */
+    skinColor?: Color3 | undefined;
+    /** default = decentraland.common.Color3(R = 0.283f, G = 0.142f, B = 0f) */
+    hairColor?: Color3 | undefined;
+    /** default = decentraland.common.Color3(R = 0.6f, G = 0.462f, B = 0.356f) */
+    eyeColor?: Color3 | undefined;
+    expressionTriggerId?: string | undefined;
+    /** default = timestamp */
+    expressionTriggerTimestamp?: number | undefined;
+    talking?: boolean | undefined;
+    /**
+     * default = ["urn:decentraland:off-chain:base-avatars:f_eyes_00",
+     *  "urn:decentraland:off-chain:base-avatars:f_eyebrows_00",
+     *  "urn:decentraland:off-chain:base-avatars:f_mouth_00"
+     *  "urn:decentraland:off-chain:base-avatars:standard_hair",
+     *  "urn:decentraland:off-chain:base-avatars:f_simple_yellow_tshirt",
+     *  "urn:decentraland:off-chain:base-avatars:f_brown_trousers",
+     *  "urn:decentraland:off-chain:base-avatars:bun_shoes"]
+     */
+    wearables: string[];
+    /** default = [] */
+    emotes: string[];
+}
+/**
+ * Internal
+ */
+export declare const PBAvatarShape: {
+    encode(message: PBAvatarShape, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarShape;
+};

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

@@ -0,0 +1,129 @@
+/* eslint-disable */
+import Long from 'long';
+import { Color3 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = '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: []
+    };
+}
+/**
+ * Internal
+ */
+export const PBAvatarShape = {
+    encode(message, writer = _m0.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) {
+            Color3.encode(message.skinColor, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.hairColor !== undefined) {
+            Color3.encode(message.hairColor, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.eyeColor !== undefined) {
+            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;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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:
+                    message.id = reader.string();
+                    break;
+                case 2:
+                    message.name = reader.string();
+                    break;
+                case 3:
+                    message.bodyShape = reader.string();
+                    break;
+                case 4:
+                    message.skinColor = Color3.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.hairColor = Color3.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.eyeColor = Color3.decode(reader, reader.uint32());
+                    break;
+                case 7:
+                    message.expressionTriggerId = reader.string();
+                    break;
+                case 8:
+                    message.expressionTriggerTimestamp = longToNumber(reader.int64());
+                    break;
+                case 9:
+                    message.talking = reader.bool();
+                    break;
+                case 10:
+                    message.wearables.push(reader.string());
+                    break;
+                case 11:
+                    message.emotes.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+var globalThis = (() => {
+    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 globalThis.Error('Value is larger than Number.MAX_SAFE_INTEGER');
+    }
+    return long.toNumber();
+}
+if (_m0.util.Long !== Long) {
+    _m0.util.Long = Long;
+    _m0.configure();
+}

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

@@ -0,0 +1,18 @@
+import _m0 from 'protobufjs/minimal';
+export declare const enum BillboardMode {
+    BM_ALL_AXES = 0,
+    BM_Y_AXE = 1
+}
+export interface PBBillboard {
+    /** default=BM_ALL_AXES */
+    billboardMode?: BillboardMode | undefined;
+    /** default=false */
+    oppositeDirection?: boolean | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBBillboard: {
+    encode(message: PBBillboard, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBBillboard;
+};

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

@@ -0,0 +1,45 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+export var BillboardMode;
+(function (BillboardMode) {
+    BillboardMode[BillboardMode["BM_ALL_AXES"] = 0] = "BM_ALL_AXES";
+    BillboardMode[BillboardMode["BM_Y_AXE"] = 1] = "BM_Y_AXE";
+})(BillboardMode || (BillboardMode = {}));
+function createBasePBBillboard() {
+    return { billboardMode: undefined, oppositeDirection: undefined };
+}
+/**
+ * Internal
+ */
+export const PBBillboard = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.billboardMode !== undefined) {
+            writer.uint32(8).int32(message.billboardMode);
+        }
+        if (message.oppositeDirection !== undefined) {
+            writer.uint32(16).bool(message.oppositeDirection);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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:
+                    message.billboardMode = reader.int32();
+                    break;
+                case 2:
+                    message.oppositeDirection = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,12 @@
+import { CameraType } from './common/camera_type.gen';
+import _m0 from 'protobufjs/minimal';
+export interface PBCameraMode {
+    mode: CameraType;
+}
+/**
+ * Internal
+ */
+export declare const PBCameraMode: {
+    encode(message: PBCameraMode, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBCameraMode;
+};