@dcl/ecs 7.1.4-4491693391.commit-569ecab → 7.1.4-4495128859.commit-9f954df

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

@@ -1,4 +1,5 @@
 import { Color3 } from "../../common/colors.gen";
+/** NftFrameType is a predefined framing style for the image. */
 /**
  * @public
  */
@@ -27,13 +28,23 @@ export declare const enum NftFrameType {
     NFT_CANVAS = 21,
     NFT_NONE = 22
 }
+/**
+ * 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.
+ */
 /**
  * @public
  */
 export interface PBNftShape {
+    /** the URI of the NFT */
     src: string;
-    /** default = PictureFrameStyle.Classic */
+    /** the frame style (default NFT_CLASSIC) */
     style?: NftFrameType | undefined;
-    /** default = decentraland.common.Color3(0.6404918, 0.611472, 0.8584906) */
+    /** RGB background (default [0.6404918, 0.611472, 0.8584906]) */
     color?: Color3 | undefined;
 }

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

@@ -2,6 +2,7 @@
 import _m0 from "protobufjs/minimal";
 import { Color3 } from "../../common/colors.gen";
 const protobufPackageSarasa = "decentraland.sdk.components";
+/** NftFrameType is a predefined framing style for the image. */
 /**
  * @public
  */

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

@@ -1,36 +1,45 @@
-import { InputAction } from "./common/input_action.gen";
+import { InputAction, PointerEventType } from "./common/input_action.gen";
 /**
- * @public
+ * PointerEvents adds configurable pointer-based interactions to the attached Entity.
+ *
+ * Events that match the criteria defined in the PointerEvents structure are reported back to the
+ * Entity via the PointerEventsResult component.
+ *
+ * Some examples of events that can be detected:
+ * - Pointer hovering over the Entity.
+ * - Held mouse button released over the Entity.
+ * - Controller button pressed while targeting the Entity.
+ * - Key pressed while targeting the Entity, but only in close range.
+ *
+ * It also supports simple visual feedback when interactions occur, by showing floating text.
+ * More sophisticated feedback requires the use of other components.
  */
-export declare const enum PointerEventType {
-    PET_UP = 0,
-    PET_DOWN = 1,
-    PET_HOVER_ENTER = 2,
-    PET_HOVER_LEAVE = 3
-}
 /**
  * @public
  */
 export interface PBPointerEvents {
+    /** the list of relevant events to detect */
     pointerEvents: PBPointerEvents_Entry[];
 }
 /**
  * @public
  */
 export interface PBPointerEvents_Info {
-    /** default=InputAction.ANY */
+    /** key/button in use (default IA_ANY) */
     button?: InputAction | undefined;
-    /** default='Interact' */
+    /** feedback on hover (default 'Interact') */
     hoverText?: string | undefined;
-    /** default=10 */
+    /** range of interaction (default 10) */
     maxDistance?: number | undefined;
-    /** default=true */
+    /** enable or disable hover text (default true) */
     showFeedback?: boolean | undefined;
 }
 /**
  * @public
  */
 export interface PBPointerEvents_Entry {
+    /** the kind of interaction to detect */
     eventType: PointerEventType;
+    /** additional configuration for this detection */
     eventInfo: PBPointerEvents_Info | undefined;
 }

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

@@ -1,16 +1,6 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
 const protobufPackageSarasa = "decentraland.sdk.components";
-/**
- * @public
- */
-export var PointerEventType;
-(function (PointerEventType) {
-    PointerEventType[PointerEventType["PET_UP"] = 0] = "PET_UP";
-    PointerEventType[PointerEventType["PET_DOWN"] = 1] = "PET_DOWN";
-    PointerEventType[PointerEventType["PET_HOVER_ENTER"] = 2] = "PET_HOVER_ENTER";
-    PointerEventType[PointerEventType["PET_HOVER_LEAVE"] = 3] = "PET_HOVER_LEAVE";
-})(PointerEventType || (PointerEventType = {}));
 function createBasePBPointerEvents() {
     return { pointerEvents: [] };
 }

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

@@ -1,6 +1,5 @@
-import { InputAction } from "./common/input_action.gen";
-import { PointerEventType } from "./pointer_events.gen";
-import { RaycastHit } from "./raycast_result.gen";
+import { InputAction, PointerEventType } from "./common/input_action.gen";
+import { RaycastHit } from "./common/raycast_hit.gen";
 /** renderer append a new object of this in each command, there can be many commands per frames */
 /**
  * @public

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

@@ -1,6 +1,6 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
-import { RaycastHit } from "./raycast_result.gen";
+import { RaycastHit } from "./common/raycast_hit.gen";
 const protobufPackageSarasa = "decentraland.sdk.components";
 function createBasePBPointerEventsResult() {
     return { button: 0, hit: undefined, state: 0, timestamp: 0, analog: undefined };
@@ -23,7 +23,7 @@ export const PBPointerEventsResult = {
             writer.uint32(32).int32(message.state);
         }
         if (message.timestamp !== 0) {
-            writer.uint32(40).int32(message.timestamp);
+            writer.uint32(40).uint32(message.timestamp);
         }
         if (message.analog !== undefined) {
             writer.uint32(53).float(message.analog);
@@ -47,7 +47,7 @@ export const PBPointerEventsResult = {
                     message.state = reader.int32();
                     break;
                 case 5:
-                    message.timestamp = reader.int32();
+                    message.timestamp = reader.uint32();
                     break;
                 case 6:
                     message.analog = reader.float();

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

@@ -1,6 +1,11 @@
+/**
+ * PointerLock indicates whether the mouse pointer is automatically following the camera’s point of
+ * focus (locked), or can move freely on the screen (unlocked).
+ */
 /**
  * @public
  */
 export interface PBPointerLock {
+    /** whether the pointer is locked */
     isPointerLocked: boolean;
 }

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

@@ -1,17 +1,55 @@
 import { Vector3 } from "../../common/vectors.gen";
+/** RaycastQueryType indicates whether the ray should stop on the first collition, or continue. */
 /**
  * @public
  */
 export declare const enum RaycastQueryType {
+    /** RQT_HIT_FIRST - Pick the first (not necessarily the closest) hit within the range */
     RQT_HIT_FIRST = 0,
-    RQT_QUERY_ALL = 1
+    /** RQT_QUERY_ALL - Pick all hits within the range */
+    RQT_QUERY_ALL = 1,
+    /** RQT_NONE - Do not perform the raycast, only set the raycast result with empty hits */
+    RQT_NONE = 2
 }
+/**
+ * The PBRaycast component and PBRaycastResult are defined in https://adr.decentraland.org/adr/ADR-200
+ *
+ * The Raycast component allows scenes to request raycasting from the game engine. The results will
+ * be available in a RaycastResult component set later on the same Entity.
+ */
 /**
  * @public
  */
 export interface PBRaycast {
-    origin: Vector3 | undefined;
-    direction: Vector3 | undefined;
+    /** Correlation ID, defined by the scene and used internally by the scene */
+    timestamp?: number | undefined;
+    /**
+     * How much to offset the starting point of the ray, relative to the entity's transform.
+     * Defaults to vec3(0,0,0)
+     */
+    originOffset?: Vector3 | undefined;
+    direction?: {
+        $case: "localDirection";
+        localDirection: Vector3;
+    } | {
+        $case: "globalDirection";
+        globalDirection: Vector3;
+    } | {
+        $case: "globalTarget";
+        globalTarget: Vector3;
+    } | {
+        $case: "targetEntity";
+        targetEntity: number;
+    };
+    /** Maximum length of the ray in virtual meters (global space) */
     maxDistance: number;
+    /** the RaycastQueryType behavior */
     queryType: RaycastQueryType;
+    /**
+     * Indicates the renderer to perform the raycast on every scene tick (ADR-148),
+     * otherwise it will be performed only once, defaults to false
+     */
+    continuous?: boolean | undefined;
+    /** Collision mask, by default all bits are 1 (0xFFFF_FFFF) */
+    collisionMask?: number | undefined;
 }

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

@@ -2,16 +2,29 @@
 import _m0 from "protobufjs/minimal";
 import { Vector3 } from "../../common/vectors.gen";
 const protobufPackageSarasa = "decentraland.sdk.components";
+/** RaycastQueryType indicates whether the ray should stop on the first collition, or continue. */
 /**
  * @public
  */
 export var RaycastQueryType;
 (function (RaycastQueryType) {
+    /** RQT_HIT_FIRST - Pick the first (not necessarily the closest) hit within the range */
     RaycastQueryType[RaycastQueryType["RQT_HIT_FIRST"] = 0] = "RQT_HIT_FIRST";
+    /** RQT_QUERY_ALL - Pick all hits within the range */
     RaycastQueryType[RaycastQueryType["RQT_QUERY_ALL"] = 1] = "RQT_QUERY_ALL";
+    /** RQT_NONE - Do not perform the raycast, only set the raycast result with empty hits */
+    RaycastQueryType[RaycastQueryType["RQT_NONE"] = 2] = "RQT_NONE";
 })(RaycastQueryType || (RaycastQueryType = {}));
 function createBasePBRaycast() {
-    return { origin: undefined, direction: undefined, maxDistance: 0, queryType: 0 };
+    return {
+        timestamp: undefined,
+        originOffset: undefined,
+        direction: undefined,
+        maxDistance: 0,
+        queryType: 0,
+        continuous: undefined,
+        collisionMask: undefined,
+    };
 }
 /**
  * @public
@@ -21,11 +34,23 @@ function createBasePBRaycast() {
  */
 export const PBRaycast = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.origin !== undefined) {
-            Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
+        if (message.timestamp !== undefined) {
+            writer.uint32(8).uint32(message.timestamp);
         }
-        if (message.direction !== undefined) {
-            Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
+        if (message.originOffset !== undefined) {
+            Vector3.encode(message.originOffset, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.direction?.$case === "localDirection") {
+            Vector3.encode(message.direction.localDirection, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.direction?.$case === "globalDirection") {
+            Vector3.encode(message.direction.globalDirection, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.direction?.$case === "globalTarget") {
+            Vector3.encode(message.direction.globalTarget, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.direction?.$case === "targetEntity") {
+            writer.uint32(80).uint32(message.direction.targetEntity);
         }
         if (message.maxDistance !== 0) {
             writer.uint32(37).float(message.maxDistance);
@@ -33,6 +58,12 @@ export const PBRaycast = {
         if (message.queryType !== 0) {
             writer.uint32(40).int32(message.queryType);
         }
+        if (message.continuous !== undefined) {
+            writer.uint32(64).bool(message.continuous);
+        }
+        if (message.collisionMask !== undefined) {
+            writer.uint32(72).uint32(message.collisionMask);
+        }
         return writer;
     },
     decode(input, length) {
@@ -42,11 +73,23 @@ export const PBRaycast = {
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
+                case 1:
+                    message.timestamp = reader.uint32();
+                    break;
                 case 2:
-                    message.origin = Vector3.decode(reader, reader.uint32());
+                    message.originOffset = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.direction = { $case: "localDirection", localDirection: Vector3.decode(reader, reader.uint32()) };
                     break;
                 case 3:
-                    message.direction = Vector3.decode(reader, reader.uint32());
+                    message.direction = { $case: "globalDirection", globalDirection: Vector3.decode(reader, reader.uint32()) };
+                    break;
+                case 7:
+                    message.direction = { $case: "globalTarget", globalTarget: Vector3.decode(reader, reader.uint32()) };
+                    break;
+                case 10:
+                    message.direction = { $case: "targetEntity", targetEntity: reader.uint32() };
                     break;
                 case 4:
                     message.maxDistance = reader.float();
@@ -54,6 +97,12 @@ export const PBRaycast = {
                 case 5:
                     message.queryType = reader.int32();
                     break;
+                case 8:
+                    message.continuous = reader.bool();
+                    break;
+                case 9:
+                    message.collisionMask = reader.uint32();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;

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

@@ -1,23 +1,22 @@
 import { Vector3 } from "../../common/vectors.gen";
+import { RaycastHit } from "./common/raycast_hit.gen";
 /**
- * @public
+ * The PBRaycast component and PBRaycastResult are defined in https://adr.decentraland.org/adr/ADR-200
+ *
+ * The RaycastResult component is added to an Entity when the results of a previously attached
+ * Raycast component are available. It contains information about the ray and any objects it
+ * collided with.
  */
-export interface PBRaycastResult {
-    timestamp: number;
-    origin: Vector3 | undefined;
-    direction: Vector3 | undefined;
-    hits: RaycastHit[];
-}
-/** Position will be relative to the scene */
 /**
  * @public
  */
-export interface RaycastHit {
-    position: Vector3 | undefined;
-    origin: Vector3 | undefined;
+export interface PBRaycastResult {
+    /** timestamp is a correlation id, copied from the PBRaycast */
+    timestamp?: number | undefined;
+    /** the starting point of the ray in global coordinates */
+    globalOrigin: Vector3 | undefined;
+    /** the direction vector of the ray in global coordinates */
     direction: Vector3 | undefined;
-    normalHit: Vector3 | undefined;
-    length: number;
-    meshName?: string | undefined;
-    entityId?: number | undefined;
+    /** zero or more hits */
+    hits: RaycastHit[];
 }

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

@@ -1,10 +1,10 @@
 /* eslint-disable */
-import Long from "long";
 import _m0 from "protobufjs/minimal";
 import { Vector3 } from "../../common/vectors.gen";
+import { RaycastHit } from "./common/raycast_hit.gen";
 const protobufPackageSarasa = "decentraland.sdk.components";
 function createBasePBRaycastResult() {
-    return { timestamp: 0, origin: undefined, direction: undefined, hits: [] };
+    return { timestamp: undefined, globalOrigin: undefined, direction: undefined, hits: [] };
 }
 /**
  * @public
@@ -14,11 +14,11 @@ function createBasePBRaycastResult() {
  */
 export const PBRaycastResult = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.timestamp !== 0) {
-            writer.uint32(8).int32(message.timestamp);
+        if (message.timestamp !== undefined) {
+            writer.uint32(8).uint32(message.timestamp);
         }
-        if (message.origin !== undefined) {
-            Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
+        if (message.globalOrigin !== undefined) {
+            Vector3.encode(message.globalOrigin, writer.uint32(18).fork()).ldelim();
         }
         if (message.direction !== undefined) {
             Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
@@ -36,10 +36,10 @@ export const PBRaycastResult = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.timestamp = reader.int32();
+                    message.timestamp = reader.uint32();
                     break;
                 case 2:
-                    message.origin = Vector3.decode(reader, reader.uint32());
+                    message.globalOrigin = Vector3.decode(reader, reader.uint32());
                     break;
                 case 3:
                     message.direction = Vector3.decode(reader, reader.uint32());
@@ -55,106 +55,3 @@ export const PBRaycastResult = {
         return message;
     },
 };
-function createBaseRaycastHit() {
-    return {
-        position: undefined,
-        origin: undefined,
-        direction: undefined,
-        normalHit: undefined,
-        length: 0,
-        meshName: undefined,
-        entityId: undefined,
-    };
-}
-/**
- * @public
- */
-/**
- * @internal
- */
-export const RaycastHit = {
-    encode(message, writer = _m0.Writer.create()) {
-        if (message.position !== undefined) {
-            Vector3.encode(message.position, writer.uint32(10).fork()).ldelim();
-        }
-        if (message.origin !== undefined) {
-            Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
-        }
-        if (message.direction !== undefined) {
-            Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
-        }
-        if (message.normalHit !== undefined) {
-            Vector3.encode(message.normalHit, writer.uint32(34).fork()).ldelim();
-        }
-        if (message.length !== 0) {
-            writer.uint32(45).float(message.length);
-        }
-        if (message.meshName !== undefined) {
-            writer.uint32(50).string(message.meshName);
-        }
-        if (message.entityId !== undefined) {
-            writer.uint32(56).int64(message.entityId);
-        }
-        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 = createBaseRaycastHit();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.position = Vector3.decode(reader, reader.uint32());
-                    break;
-                case 2:
-                    message.origin = Vector3.decode(reader, reader.uint32());
-                    break;
-                case 3:
-                    message.direction = Vector3.decode(reader, reader.uint32());
-                    break;
-                case 4:
-                    message.normalHit = Vector3.decode(reader, reader.uint32());
-                    break;
-                case 5:
-                    message.length = reader.float();
-                    break;
-                case 6:
-                    message.meshName = reader.string();
-                    break;
-                case 7:
-                    message.entityId = longToNumber(reader.int64());
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-};
-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 (_m0.util.Long !== Long) {
-    _m0.util.Long = Long;
-    _m0.configure();
-}

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

@@ -1,39 +1,57 @@
 import { Color3, Color4 } from "../../common/colors.gen";
 import { Font, TextAlignMode } from "./common/texts.gen";
+/**
+ * The TextShape component renders customizable floating text.
+ *
+ * The position and rotation of the text are defined by the Entity's Transform, while its size
+ * can either scale with the Transform or be fixed by a font size.
+ *
+ * Several options can be configured, including color, padding, line spacing and drop shadows.
+ */
 /**
  * @public
  */
 export interface PBTextShape {
+    /** the content */
     text: string;
-    /** default=F_SANS_SERIF */
+    /** the font (default F_SANS_SERIF) */
     font?: Font | undefined;
-    /** default=10 */
+    /** the font size (default 10) */
     fontSize?: number | undefined;
+    /** override `font_size` to automatically fit in `width`/`height` */
     fontAutoSize?: boolean | undefined;
-    /** default=TAM_CENTER_CENTER */
+    /** X and Y alignment (default TAM_CENTER_CENTER) */
     textAlign?: TextAlignMode | undefined;
-    /** default=1 */
+    /** available horizontal space (default 1) */
     width?: number | undefined;
-    /** default=1 */
+    /** available vertical space (default 1) */
     height?: number | undefined;
+    /** distance from text to top border (default 0) */
     paddingTop?: number | undefined;
+    /** distance from text to right border (default 0) */
     paddingRight?: number | undefined;
+    /** distance from text to bottom border (default 0) */
     paddingBottom?: number | undefined;
+    /** distance from text to left border (default 0) */
     paddingLeft?: number | undefined;
-    /** The amount of additional spacing to add between each lines of text. */
+    /** extra distance between lines (default 0) */
     lineSpacing?: number | undefined;
-    /** Allows control over how many lines of text are displayed. */
+    /** maximum number of lines to display */
     lineCount?: number | undefined;
-    /** Enables text wrapping */
+    /** wrap text when the border is reached (default false) */
     textWrapping?: boolean | undefined;
+    /** blurriness of the drop shadow (default 0) */
     shadowBlur?: number | undefined;
+    /** horizontal length of the shadow (default 0) */
     shadowOffsetX?: number | undefined;
+    /** vertical length of the shadow (default 0) */
     shadowOffsetY?: number | undefined;
+    /** width of the stroke outlining each letter (default 0) */
     outlineWidth?: number | undefined;
-    /** default=(1.0,1.0,1.0) */
+    /** drop shadow color (default [1.0, 1.0, 1.0]) */
     shadowColor?: Color3 | undefined;
-    /** default=(1.0,1.0,1.0) */
+    /** outline stroke color (default [1.0, 1.0, 1.0]) */
     outlineColor?: Color3 | undefined;
-    /** default=(1.0,1.0,1.0) */
+    /** text color (default [1.0, 1.0, 1.0]) */
     textColor?: Color4 | undefined;
 }

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

@@ -4,13 +4,14 @@ import { Font, TextAlignMode } from "./common/texts.gen";
  * @public
  */
 export interface PBUiText {
+    /** the text content */
     value: string;
-    /** default=(1.0,1.0,1.0,1.0) */
+    /** RGBA color (default: opaque white) */
     color?: Color4 | undefined;
-    /** default='center' */
+    /** alignment within the bounds (default: center) */
     textAlign?: TextAlignMode | undefined;
-    /** default=0 */
+    /** font for the text (default: sans-serif) */
     font?: Font | undefined;
-    /** default=10 */
+    /** size of the text (default: 10) */
     fontSize?: number | undefined;
 }

package/dist/components/generated/types.gen.d.ts

@@ -2,6 +2,7 @@ export type { Position as PBPosition, Vector2 as PBVector2, Vector3 as PBVector3
 export type { Color3 as PBColor3, Color4 as PBColor4 } from './pb/decentraland/common/colors.gen';
 export * from './pb/decentraland/sdk/components/common/camera_type.gen';
 export * from './pb/decentraland/sdk/components/common/input_action.gen';
+export * from './pb/decentraland/sdk/components/common/raycast_hit.gen';
 export * from './pb/decentraland/sdk/components/common/texts.gen';
 export * from './pb/decentraland/common/border_rect.gen';
 export * from './pb/decentraland/common/texture.gen';

package/dist/components/generated/types.gen.js

@@ -2,6 +2,8 @@ export * from './pb/decentraland/sdk/components/common/camera_type.gen';
 // export { PbCameraType }
 export * from './pb/decentraland/sdk/components/common/input_action.gen';
 // export { PbInputAction }
+export * from './pb/decentraland/sdk/components/common/raycast_hit.gen';
+// export { PbRaycastHit }
 export * from './pb/decentraland/sdk/components/common/texts.gen';
 // export { PbTexts }
 export * from './pb/decentraland/common/border_rect.gen';

package/dist/engine/input.d.ts

@@ -1,5 +1,5 @@
 import { InputAction } from '../components/generated/pb/decentraland/sdk/components/common/input_action.gen';
-import { PointerEventType } from '../components/generated/pb/decentraland/sdk/components/pointer_events.gen';
+import { PointerEventType } from '../components/generated/pb/decentraland/sdk/components/common/input_action.gen';
 import { PBPointerEventsResult } from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
 import { Entity } from './entity';
 /**