@dcl/playground-assets 7.1.4-4492843881.commit-442dfb1 → 7.1.4-4502579506.commit-4147243

package/dist/alpha.d.ts

@@ -89,6 +89,7 @@ export declare const AudioSource: LastWriteWinElementSetComponentDefinition<PBAu
 /** @public */
 export declare const AudioStream: LastWriteWinElementSetComponentDefinition<PBAudioStream>;
 
+/** AvatarAnchorPointType determines the part of the avatar's body that anchors the Entity. */
 /**
  * @public
  */
@@ -105,11 +106,14 @@ export declare const AvatarAttach: LastWriteWinElementSetComponentDefinition<PBA
 /** @public */
 export declare const AvatarModifierArea: LastWriteWinElementSetComponentDefinition<PBAvatarModifierArea>;
 
+/** 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
 }
 
@@ -203,6 +207,7 @@ export declare interface BaseComponent<T> {
 /** @public */
 export declare const Billboard: LastWriteWinElementSetComponentDefinition<PBBillboard>;
 
+/** BillboardMode indicates one or more axis for automatic rotation, in OR-able bit flag form. */
 /**
  * @public
  */
@@ -211,6 +216,7 @@ export declare const enum BillboardMode {
     BM_X = 1,
     BM_Y = 2,
     BM_Z = 4,
+    /** BM_ALL - bitwise combination BM_X | BM_Y | BM_Z */
     BM_ALL = 7
 }
 
@@ -361,18 +367,39 @@ export declare const CameraModeArea: LastWriteWinElementSetComponentDefinition<P
  */
 export declare const enum CameraType {
     CT_FIRST_PERSON = 0,
-    CT_THIRD_PERSON = 1
+    CT_THIRD_PERSON = 1,
+    /** CT_CINEMATIC - controlled by the scene */
+    CT_CINEMATIC = 2
 }
 
 export declare type Children = unknown;
 
+/** ColliderLayer determines the kind of collision to detect, in OR-able bit flag form. */
 /**
  * @public
  */
 export declare const enum ColliderLayer {
+    /** CL_NONE - no collisions */
     CL_NONE = 0,
+    /** CL_POINTER - collisions with the player's pointer ray (e.g. mouse cursor hovering) */
     CL_POINTER = 1,
-    CL_PHYSICS = 2
+    /** CL_PHYSICS - collision affecting your player's physics i.e. walls, floor, moving platfroms */
+    CL_PHYSICS = 2,
+    /** CL_VISIBLE_MESHES - all visible meshes, use with extreme care since the performance penalty is high */
+    CL_VISIBLE_MESHES = 4,
+    CL_RESERVED2 = 8,
+    CL_RESERVED3 = 16,
+    CL_RESERVED4 = 32,
+    CL_RESERVED5 = 64,
+    CL_RESERVED6 = 128,
+    CL_CUSTOM1 = 256,
+    CL_CUSTOM2 = 512,
+    CL_CUSTOM3 = 1024,
+    CL_CUSTOM4 = 2048,
+    CL_CUSTOM5 = 4096,
+    CL_CUSTOM6 = 8192,
+    CL_CUSTOM7 = 16384,
+    CL_CUSTOM8 = 32768
 }
 
 /**
@@ -3068,6 +3095,7 @@ export declare class MessageBus {
     private flush;
 }
 
+/** NftFrameType is a predefined framing style for the image. */
 /**
  * @public
  */
@@ -3230,123 +3258,229 @@ export declare const onVideoEvent: Observable<{
  */
 export declare type OverflowType = 'hidden' | 'scroll' | 'visible';
 
+/** AnimationState indicates the status and configuration of one available animation. */
 /**
  * @public
  */
 export declare interface PBAnimationState {
+    /** the identifier for this animation, to use in scene code */
     name: string;
+    /** the animation path in the `files` array of the scene manifest */
     clip: string;
+    /** whether this animation is currently playing */
     playing?: boolean | undefined;
-    /** default=1.0s */
+    /** the "weight" of this animation (see below, default: 1.0) */
     weight?: number | undefined;
-    /** default=1.0 */
+    /** the playback speed (default: 1.0) */
     speed?: number | undefined;
-    /** default=true */
+    /** whether the animation repeats until stopped (default: true) */
     loop?: boolean | undefined;
+    /** whether the Entity is restored to its prior state when done */
     shouldReset?: boolean | undefined;
 }
 
+/**
+ * The Animator component is a container for multiple potential animations an Entity can display,
+ * separately or at the same time. It can be used to start, stop or blend animations; as well as
+ * to inspect their playback state.
+ *
+ * Animations have a `weight` property, which determines how pronounced the animation will be. This
+ * can be adjusted to blend animations together, or gracefully transition from one to the next.
+ */
 /**
  * @public
  */
 export declare interface PBAnimator {
+    /** a collection of animations and their current state */
     states: PBAnimationState[];
 }
 
+/**
+ * The AudioSource component can play an audio clips bundled with the scene, controlling some
+ * of the behavior.
+ *
+ * In each AudioSource instance, the sound is spatially located at the associated entity’s position,
+ * given by its Transform.
+ *
+ * Note that the `audio_clip_url` is not actually a URL, but rather the path of a file bundled with
+ * the scene and declared in its manifest. The name was chosen because the URL use-case will
+ * eventually be supported.
+ */
 /**
  * @public
  */
 export declare interface PBAudioSource {
+    /** whether the clip is currently playing. */
     playing?: boolean | undefined;
-    /** default=1.0f */
+    /** the audio volume (default: 1.0). */
     volume?: number | undefined;
+    /** whether the clip should restart when finished. */
     loop?: boolean | undefined;
-    /** default=1.0f */
+    /** the audio pitch (default: 1.0). */
     pitch?: number | undefined;
+    /** the clip path as given in the `files` array of the scene's manifest. */
     audioClipUrl: string;
 }
 
+/**
+ * The AudioStream component can play external audio clips given a URL, streaming it in real-time.
+ *
+ * Despite being attached to a particular entity, the sound is not affected by its position.
+ */
 /**
  * @public
  */
 export declare interface PBAudioStream {
+    /** whether the clip is currently playing */
     playing?: boolean | undefined;
-    /** default=1.0f */
+    /** the audio volume (default: 1.0) */
     volume?: number | undefined;
+    /** the audio stream HTTP URL */
     url: string;
 }
 
+/**
+ * The AvatarAttach component automatically repositions an Entity to maintain the same position and
+ * rotation relative to some part of an avatar, called the "anchor point". The Entity
+ * will follow this anchor as it moves.
+ *
+ * The Entity's own Transform is overridden by this component. To offset position and adjust scale,
+ * add a child to the anchored Entity and set a Transform on it instead.
+ *
+ * AvatarAnchorPointType indicates which part of the avatar the Entity must follow.
+ */
 /**
  * @public
  */
 export declare interface PBAvatarAttach {
-    /** default's to current player avatar id if not provided */
+    /** the user ID of the avatar (default: local user) */
     avatarId?: string | undefined;
+    /** the anchor point. */
     anchorPointId: AvatarAnchorPointType;
 }
 
+/**
+ * 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 declare interface PBAvatarModifierArea {
+    /** the 3D size of the region */
     area: PBVector3 | undefined;
+    /** user IDs that can enter and remain unaffected */
     excludeIds: string[];
+    /** list of modifiers to apply */
     modifiers: AvatarModifierType[];
 }
 
+/**
+ * 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 declare interface PBAvatarShape {
+    /** the user ID */
     id: string;
-    /** default = NPC */
+    /** visible name (default: "NPC") */
     name?: string | undefined;
-    /** default = urn:decentraland:off-chain:base-avatars:BaseFemale */
+    /** shape URN (default "urn:decentraland:off-chain:base-avatars:BaseFemale") */
     bodyShape?: string | undefined;
-    /** default = decentraland.common.Color3(R = 0.6f, G = 0.462f, B = 0.356f) */
+    /** RGB (default [0.6, 0.462, 0.356]) */
     skinColor?: PBColor3 | undefined;
-    /** default = decentraland.common.Color3(R = 0.283f, G = 0.142f, B = 0f) */
+    /** RGB (default [0.283, 0.142, 0]) */
     hairColor?: PBColor3 | undefined;
-    /** default = decentraland.common.Color3(R = 0.6f, G = 0.462f, B = 0.356f) */
+    /** RGB (default [0.6, 0.462, 0.356]) */
     eyeColor?: PBColor3 | undefined;
+    /** current emote animations */
     expressionTriggerId?: string | undefined;
-    /** default = timestamp */
+    /** start of emote animations (in the same order) */
     expressionTriggerTimestamp?: number | undefined;
+    /** whether to display the floating voice chat icon */
     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"]
+     * 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[];
-    /** default = [] */
+    /** available emotes (default empty) */
     emotes: string[];
 }
 
+/**
+ * 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 declare interface PBBillboard {
-    /** default=BM_ALL */
+    /** the BillboardMode (default: BM_ALL) */
     billboardMode?: BillboardMode | undefined;
 }
 
+/**
+ * The CameraMode component can be used to determine whether the player is using a first-person o
+ * third-person view.
+ */
 /**
  * @public
  */
 export declare interface PBCameraMode {
+    /** the camera type (1st-person or 3rd-person) */
     mode: CameraType;
 }
 
+/**
+ * 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 declare interface PBCameraModeArea {
+    /** the 3D size of the region */
     area: PBVector3 | undefined;
+    /** the camera mode to enforce */
     mode: CameraType;
 }
 
@@ -3369,11 +3503,17 @@ export declare interface PBColor4 {
     a: number;
 }
 
+/**
+ * GltfContainer loads a GLTF file (and any additional files packaged inside) attached to an Entity.
+ *
+ * This allows the use of custom models, materials, collision boundaries and shapes that can't be
+ * achieved using MeshRenderer, MeshCollider and other standard components.
+ */
 /**
  * @public
  */
 export declare interface PBGltfContainer {
-    /** which file to load */
+    /** the GLTF file path as listed in the scene's manifest. */
     src: string;
 }
 
@@ -3442,11 +3582,21 @@ export declare interface PBMaterial_UnlitMaterial {
     diffuseColor?: PBColor4 | undefined;
 }
 
+/**
+ * The MeshCollider component provides basic collision detection between Entities and Avatars. It
+ * can behave like a cube, a plane, a sphere or a cylinder.
+ *
+ * The Entity's Transform affects the MeshCollider, scaling it and rotating it appropriately. If
+ * the Transform for the collision mesh must be different than the Transform for rendering the Entity,
+ * two different Entities must be used.
+ *
+ * More complex shapes require the use of a `GltfContainer` component.
+ */
 /**
  * @public
  */
 export declare interface PBMeshCollider {
-    /** default = ColliderLayer.Physics | ColliderLayer.Pointer */
+    /** enabled ColliderLayers (default CL_POINTER | CL_PHYSICS) */
     collisionMask?: number | undefined;
     mesh?: {
         $case: "box";
@@ -3463,34 +3613,48 @@ export declare interface PBMeshCollider {
     };
 }
 
+/** BoxMesh is a prism shape that contains the Entity. */
 /**
  * @public
  */
 export declare interface PBMeshCollider_BoxMesh {
 }
 
+/** CylinderMesh is a truncated cone shape that contains the Entity. */
 /**
  * @public
  */
 export declare interface PBMeshCollider_CylinderMesh {
-    /** default=1.0 */
+    /** (default 1.0) */
     radiusTop?: number | undefined;
-    /** default=1.0 */
+    /** (default 1.0) */
     radiusBottom?: number | undefined;
 }
 
+/** PlaneMesh is a 2D rectangle described by the Entity's Transform. */
 /**
  * @public
  */
 export declare interface PBMeshCollider_PlaneMesh {
 }
 
+/** SphereMesh is a sphere shape that contains the Entity. */
 /**
  * @public
  */
 export declare interface PBMeshCollider_SphereMesh {
 }
 
+/**
+ * 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
  */
@@ -3510,51 +3674,83 @@ export declare interface PBMeshRenderer {
     };
 }
 
+/** BoxMesh renders a prism shape. */
 /**
  * @public
  */
 export declare interface PBMeshRenderer_BoxMesh {
+    /** 96-value texture map (2D * 6 faces * 2 sides * 4 vertices) */
     uvs: number[];
 }
 
+/** CylinderMesh renders a truncated cone shape. */
 /**
  * @public
  */
 export declare interface PBMeshRenderer_CylinderMesh {
-    /** default=1.0 */
+    /** (default 1.0) */
     radiusTop?: number | undefined;
-    /** default=1.0 */
+    /** (default 1.0) */
     radiusBottom?: number | undefined;
 }
 
+/** PlaneMesh renders a 2D rectangular shape. */
 /**
  * @public
  */
 export declare interface PBMeshRenderer_PlaneMesh {
+    /** 16-value texture map (2D * 1 face * 2 sides * 4 vertices) */
     uvs: number[];
 }
 
+/** SphereMesh renders a spherical shape. */
 /**
  * @public
  */
 export declare interface PBMeshRenderer_SphereMesh {
 }
 
+/**
+ * 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 declare 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?: PBColor3 | undefined;
 }
 
+/**
+ * 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.
+ */
 /**
  * @public
  */
 export declare interface PBPointerEvents {
+    /** the list of relevant events to detect */
     pointerEvents: PBPointerEvents_Entry[];
 }
 
@@ -3562,7 +3758,9 @@ export declare interface PBPointerEvents {
  * @public
  */
 export declare interface PBPointerEvents_Entry {
+    /** the kind of interaction to detect */
     eventType: PointerEventType;
+    /** additional configuration for this detection */
     eventInfo: PBPointerEvents_Info | undefined;
 }
 
@@ -3570,13 +3768,13 @@ export declare interface PBPointerEvents_Entry {
  * @public
  */
 export declare 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;
 }
 
@@ -3595,10 +3793,15 @@ export declare interface PBPointerEventsResult {
     analog?: number | undefined;
 }
 
+/**
+ * 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 declare interface PBPointerLock {
+    /** whether the pointer is locked */
     isPointerLocked: boolean;
 }
 
@@ -3611,61 +3814,123 @@ export declare interface PBPosition {
     z: number;
 }
 
+/**
+ * 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 declare interface PBRaycast {
-    origin: PBVector3 | undefined;
-    direction: PBVector3 | 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?: PBVector3 | undefined;
+    direction?: {
+        $case: "localDirection";
+        localDirection: PBVector3;
+    } | {
+        $case: "globalDirection";
+        globalDirection: PBVector3;
+    } | {
+        $case: "globalTarget";
+        globalTarget: PBVector3;
+    } | {
+        $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;
 }
 
+/**
+ * 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.
+ */
 /**
  * @public
  */
 export declare interface PBRaycastResult {
-    timestamp: number;
-    origin: PBVector3 | undefined;
+    /** timestamp is a correlation id, copied from the PBRaycast */
+    timestamp?: number | undefined;
+    /** the starting point of the ray in global coordinates */
+    globalOrigin: PBVector3 | undefined;
+    /** the direction vector of the ray in global coordinates */
     direction: PBVector3 | undefined;
+    /** zero or more hits */
     hits: RaycastHit[];
 }
 
+/**
+ * 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 declare 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?: PBColor3 | undefined;
-    /** default=(1.0,1.0,1.0) */
+    /** outline stroke color (default [1.0, 1.0, 1.0]) */
     outlineColor?: PBColor3 | undefined;
-    /** default=(1.0,1.0,1.0) */
+    /** text color (default [1.0, 1.0, 1.0]) */
     textColor?: PBColor4 | undefined;
 }
 
@@ -3740,14 +4005,15 @@ export declare interface PBUiInputResult {
  * @public
  */
 export declare interface PBUiText {
+    /** the text content */
     value: string;
-    /** default=(1.0,1.0,1.0,1.0) */
+    /** RGBA color (default: opaque white) */
     color?: PBColor4 | 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;
 }
 
@@ -4044,6 +4310,7 @@ export declare interface PointerEventsSystem {
  */
 export declare const pointerEventsSystem: PointerEventsSystem;
 
+/** PointerEventType is a kind of interaction that can be detected. */
 /**
  * @public
  */
@@ -4440,26 +4707,38 @@ export declare const RAD2DEG: number;
 /** @public */
 export declare const Raycast: LastWriteWinElementSetComponentDefinition<PBRaycast>;
 
-/** Position will be relative to the scene */
+/** RaycastHit contains information about the intersection of a ray with a mesh. */
 /**
  * @public
  */
 export declare interface RaycastHit {
+    /** Position will be relative to the scene */
     position: PBVector3 | undefined;
-    origin: PBVector3 | undefined;
+    /** the starting point of the ray in global coordinates */
+    globalOrigin: PBVector3 | undefined;
+    /** the direction vector of the ray in global coordinates */
     direction: PBVector3 | undefined;
+    /** normal of the hit surface in global coordinates */
     normalHit: PBVector3 | undefined;
+    /** the distance between the ray origin and the hit position */
     length: number;
+    /** mesh name, if collision happened inside a GltfContainer */
     meshName?: string | undefined;
+    /** the ID of the Entity that has the impacted mesh attached */
     entityId?: number | undefined;
 }
 
+/** 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
 }
 
 export declare type RaycastResponsePayload<T> = {