@dcl/sdk 7.0.0-2805922413.commit-7f80d4a → 7.0.0-2884920754.commit-e7fba73

package/dist/ecs7/index.d.ts

@@ -16,10 +16,11 @@ declare const enum ActionButton {
     UNRECOGNIZED = -1
 }
 
-/**
- * @public
- */
-export declare function ArrayType<T>(type: EcsType<T>): EcsType<Array<T>>;
+/** @public */
+export declare const Animator: ComponentDefinition<ISchema<PBAnimator>>;
+
+/** @public */
+export declare const AudioSource: ComponentDefinition<ISchema<PBAudioSource>>;
 
 declare const enum AvatarAnchorPoint {
     POSITION = 0,
@@ -29,11 +30,29 @@ declare const enum AvatarAnchorPoint {
     UNRECOGNIZED = -1
 }
 
+/** @public */
+export declare const AvatarAttach: ComponentDefinition<ISchema<PBAvatarAttach>>;
+
+/** @public */
+export declare const AvatarShape: ComponentDefinition<ISchema<PBAvatarShape>>;
+
+/** @public */
+export declare const Billboard: ComponentDefinition<ISchema<PBBillboard>>;
+
+/** @public */
+export declare const BoxShape: ComponentDefinition<ISchema<PBBoxShape>>;
+
 /**
  * @public
  */
 export declare type ByteBuffer = ReturnType<typeof createByteBuffer>;
 
+/** @public */
+export declare const CameraMode: ComponentDefinition<ISchema<PBCameraMode>>;
+
+/** @public */
+export declare const CameraModeArea: ComponentDefinition<ISchema<PBCameraModeArea>>;
+
 declare const enum CameraModeValue {
     FIRST_PERSON = 0,
     THIRD_PERSON = 1,
@@ -49,36 +68,203 @@ declare interface Color3 {
 /**
  * @public
  */
-export declare type ComponentDefinition<T extends EcsType = EcsType<any>> = {
+export declare type ComponentDefinition<T extends ISchema = ISchema<any>> = {
     _id: number;
+    /**
+     * Return the default value of the current component
+     */
+    default(): DeepReadonly<ComponentType<T>>;
+    /**
+     * Get if the entity has this component
+     * @param entity
+     *
+     * Example:
+     * ```ts
+     * const myEntity = engine.addEntity()
+     * Transform.has(myEntity) // return false
+     * Transform.create(myEntity)
+     * Transform.has(myEntity) // return true
+     * ```
+     */
     has(entity: Entity): boolean;
-    getFrom(entity: Entity): DeepReadonly<ComponentType<T>>;
+    /**
+     * Get the readonly component of the entity (to mutate it, use getMutable instead), throw an error if the entity doesn't have the component.
+     * @param entity
+     * @return
+     * Example:
+     * ```ts
+     * const myEntity = engine.addEntity()
+     * Transform.create(myEntity)
+     * const transform = Transform.get(myEntity) // return true
+     * log(transform.position.x === 0) // log 'true'
+     *
+     * transform.position.y = 10 // illegal statement, to mutate the component use getMutable
+     * ```
+     *
+     * ```ts
+     * const otherEntity = engine.addEntity()
+     * Transform.get(otherEntity) // throw an error!!
+     * ```
+     */
+    get(entity: Entity): DeepReadonly<ComponentType<T>>;
+    /**
+     * Get the readonly component of the entity (to mutate it, use getMutable instead), or null if the entity doesn't have the component.
+     * @param entity
+     * @return
+     *
+     * Example:
+     * ```ts
+     * const otherEntity = engine.addEntity()
+     * log(Transform.get(otherEntity) === null) // log 'true'
+     * ```
+     */
     getOrNull(entity: Entity): DeepReadonly<ComponentType<T>> | null;
+    /**
+     * Add the current component to an entity, throw an error if the component already exists (use `createOrReplace` instead).
+     * - Internal comment: This method adds the <entity,component> to the list to be reviewed next frame
+     * @param entity
+     * @param val The initial value
+     *
+     * Example:
+     * ```ts
+     * const myEntity = engine.addEntity()
+     * Transform.create(myEntity, { ...Transform.default(), position: {x: 4, y: 0, z: 4} }) // ok!
+     * Transform.create(myEntity) // throw an error, the `Transform` component already exists in `myEntity`
+     * ````
+     */
     create(entity: Entity, val?: ComponentType<T>): ComponentType<T>;
-    mutable(entity: Entity): ComponentType<T>;
+    /**
+     * Add the current component to an entity or replace the content if the entity already has the component
+     * - Internal comment: This method adds the <entity,component> to the list to be reviewed next frame
+     * @param entity
+     * @param val The initial or new value
+     *
+     * Example:
+     * ```ts
+     * const myEntity = engine.addEntity()
+     * Transform.create(myEntity) // ok!
+     * Transform.createOrReplace(myEntity, { ...Transform.default(), position: {x: 4, y: 0, z: 4} }) // ok!
+     * ````
+     */
     createOrReplace(entity: Entity, val?: ComponentType<T>): ComponentType<T>;
+    /**
+     * Delete the current component to an entity, return null if the entity doesn't have the current component.
+     * - Internal comment: This method adds the <entity,component> to the list to be reviewed next frame
+     * @param entity
+     *
+     * Example:
+     * ```ts
+     * const myEntity = engine.addEntity()
+     * Transform.create(myEntity) // ok!
+     * Transform.deleteFrom(myEntity) // return the component
+     * Transform.deleteFrom(myEntity) // return null
+     * ````
+     */
     deleteFrom(entity: Entity): ComponentType<T> | null;
-    upsertFromBinary(entity: Entity, data: ByteBuffer): ComponentType<T> | null;
-    updateFromBinary(entity: Entity, data: ByteBuffer): ComponentType<T> | null;
-    toBinary(entity: Entity): ByteBuffer;
+    /**
+     * Get the mutable component of the entity, throw an error if the entity doesn't have the component.
+     * - Internal comment: This method adds the <entity,component> to the list to be reviewed next frame
+     * @param entity
+     *
+     * Example:
+     * ```ts
+     * const myEntity = engine.addEntity()
+     * Transform.create(myEntity)
+     * Transform.getMutable(myEntity).position = {x: 4, y: 0, z: 4}
+     * ````
+     */
+    getMutable(entity: Entity): ComponentType<T>;
+    /**
+     * Get the mutable component of the entity, return null if the entity doesn't have the component.
+     * - Internal comment: This method adds the <entity,component> to the list to be reviewed next frame
+     * @param entity
+     *
+     * Example:
+     * ```ts
+     * const transform = Transform.getMutableOrNull(myEntity)
+     * if (transform) {
+     *   transform.position = {x: 4, y: 0, z: 4}
+     * }
+     * ````
+     */
+    getMutableOrNull(entity: Entity): ComponentType<T> | null;
     writeToByteBuffer(entity: Entity, buffer: ByteBuffer): void;
-    iterator(): Iterable<[Entity, ComponentType<T>]>;
-    dirtyIterator(): Iterable<Entity>;
-    clearDirty(): void;
-    isDirty(entity: Entity): boolean;
 };
 
+/** @public */
+export declare namespace Components {
+    /** @public */
+    const Transform: ComponentDefinition<ISchema<    {
+    position: {
+    x: number;
+    y: number;
+    z: number;
+    };
+    rotation: {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    };
+    scale: {
+    x: number;
+    y: number;
+    /** @public */
+    z: number;
+    };
+    parent?: Entity | undefined;
+    }>>;
+    /** @public */
+    const Animator: ComponentDefinition<ISchema<PBAnimator>>;
+    /** @public */
+    const AudioSource: ComponentDefinition<ISchema<PBAudioSource>>;
+    /** @public */
+    const AvatarAttach: ComponentDefinition<ISchema<PBAvatarAttach>>;
+    /** @public */
+    const AvatarShape: ComponentDefinition<ISchema<PBAvatarShape>>;
+    /** @public */
+    const Billboard: ComponentDefinition<ISchema<PBBillboard>>;
+    /** @public */
+    const BoxShape: ComponentDefinition<ISchema<PBBoxShape>>;
+    /** @public */
+    const CameraMode: ComponentDefinition<ISchema<PBCameraMode>>;
+    /** @public */
+    const CameraModeArea: ComponentDefinition<ISchema<PBCameraModeArea>>;
+    /** @public */
+    const CylinderShape: ComponentDefinition<ISchema<PBCylinderShape>>;
+    /** @public */
+    const GLTFShape: ComponentDefinition<ISchema<PBGLTFShape>>;
+    /** @public */
+    const NFTShape: ComponentDefinition<ISchema<PBNFTShape>>;
+    /** @public */
+    const OnPointerDown: ComponentDefinition<ISchema<PBOnPointerDown>>;
+    /** @public */
+    const OnPointerDownResult: ComponentDefinition<ISchema<PBOnPointerDownResult>>;
+    /** @public */
+    const OnPointerUp: ComponentDefinition<ISchema<PBOnPointerUp>>;
+    /** @public */
+    const OnPointerUpResult: ComponentDefinition<ISchema<PBOnPointerUpResult>>;
+    /** @public */
+    const PlaneShape: ComponentDefinition<ISchema<PBPlaneShape>>;
+    /** @public */
+    const PointerLock: ComponentDefinition<ISchema<PBPointerLock>>;
+    /** @public */
+    const SphereShape: ComponentDefinition<ISchema<PBSphereShape>>;
+    /** @public */
+    const TextShape: ComponentDefinition<ISchema<PBTextShape>>;
+}
+
 /**
  * @public
  */
-export declare type ComponentEcsType<T extends [ComponentDefinition, ...ComponentDefinition[]]> = {
-    [K in keyof T]: T[K] extends ComponentDefinition ? ReturnType<T[K]['mutable']> : never;
+export declare type ComponentSchema<T extends [ComponentDefinition, ...ComponentDefinition[]]> = {
+    [K in keyof T]: T[K] extends ComponentDefinition ? ReturnType<T[K]['getMutable']> : never;
 };
 
 /**
  * @public
  */
-export declare type ComponentType<T extends EcsType> = EcsResult<T>;
+export declare type ComponentType<T extends ISchema> = EcsResult<T>;
 
 /**
  * ByteBuffer is a wrapper of DataView which also adds a read and write offset.
@@ -218,6 +404,9 @@ declare interface CreateByteBufferOptions {
     initialCapacity?: number;
 }
 
+/** @public */
+export declare const CylinderShape: ComponentDefinition<ISchema<PBCylinderShape>>;
+
 /**
  * Make each field readonly deeply
  * @public
@@ -226,27 +415,45 @@ export declare type DeepReadonly<T> = {
     readonly [P in keyof T]: DeepReadonly<T[P]>;
 };
 
-declare function defineSdkComponents(engine: Pick<IEngine, 'defineComponent'>): {
-    Animator: ComponentDefinition<EcsType<PBAnimator>>;
-    AudioSource: ComponentDefinition<EcsType<PBAudioSource>>;
-    AvatarAttach: ComponentDefinition<EcsType<PBAvatarAttach>>;
-    AvatarShape: ComponentDefinition<EcsType<PBAvatarShape>>;
-    Billboard: ComponentDefinition<EcsType<PBBillboard>>;
-    BoxShape: ComponentDefinition<EcsType<PBBoxShape>>;
-    CameraMode: ComponentDefinition<EcsType<PBCameraMode>>;
-    CameraModeArea: ComponentDefinition<EcsType<PBCameraModeArea>>;
-    CylinderShape: ComponentDefinition<EcsType<PBCylinderShape>>;
-    GLTFShape: ComponentDefinition<EcsType<PBGLTFShape>>;
-    NFTShape: ComponentDefinition<EcsType<PBNFTShape>>;
-    OnPointerDown: ComponentDefinition<EcsType<PBOnPointerDown>>;
-    OnPointerDownResult: ComponentDefinition<EcsType<PBOnPointerDownResult>>;
-    OnPointerUp: ComponentDefinition<EcsType<PBOnPointerUp>>;
-    OnPointerUpResult: ComponentDefinition<EcsType<PBOnPointerUpResult>>;
-    PlaneShape: ComponentDefinition<EcsType<PBPlaneShape>>;
-    PointerLock: ComponentDefinition<EcsType<PBPointerLock>>;
-    SphereShape: ComponentDefinition<EcsType<PBSphereShape>>;
-    TextShape: ComponentDefinition<EcsType<PBTextShape>>;
-    Transform: ComponentDefinition<EcsType<Transform>>;
+declare function defineLibraryComponents({ defineComponentFromSchema }: Pick<IEngine, 'defineComponentFromSchema'>): {
+    Transform: ComponentDefinition<ISchema<    {
+    position: {
+    x: number;
+    y: number;
+    z: number;
+    };
+    rotation: {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    };
+    scale: {
+    x: number;
+    y: number;
+    z: number;
+    };
+    parent?: Entity | undefined;
+    }>>;
+    Animator: ComponentDefinition<ISchema<PBAnimator>>;
+    AudioSource: ComponentDefinition<ISchema<PBAudioSource>>;
+    AvatarAttach: ComponentDefinition<ISchema<PBAvatarAttach>>;
+    AvatarShape: ComponentDefinition<ISchema<PBAvatarShape>>;
+    Billboard: ComponentDefinition<ISchema<PBBillboard>>;
+    BoxShape: ComponentDefinition<ISchema<PBBoxShape>>;
+    CameraMode: ComponentDefinition<ISchema<PBCameraMode>>;
+    CameraModeArea: ComponentDefinition<ISchema<PBCameraModeArea>>;
+    CylinderShape: ComponentDefinition<ISchema<PBCylinderShape>>;
+    GLTFShape: ComponentDefinition<ISchema<PBGLTFShape>>;
+    NFTShape: ComponentDefinition<ISchema<PBNFTShape>>;
+    OnPointerDown: ComponentDefinition<ISchema<PBOnPointerDown>>;
+    OnPointerDownResult: ComponentDefinition<ISchema<PBOnPointerDownResult>>;
+    OnPointerUp: ComponentDefinition<ISchema<PBOnPointerUp>>;
+    OnPointerUpResult: ComponentDefinition<ISchema<PBOnPointerUpResult>>;
+    PlaneShape: ComponentDefinition<ISchema<PBPlaneShape>>;
+    PointerLock: ComponentDefinition<ISchema<PBPointerLock>>;
+    SphereShape: ComponentDefinition<ISchema<PBSphereShape>>;
+    TextShape: ComponentDefinition<ISchema<PBTextShape>>;
 };
 
 /**
@@ -261,26 +468,7 @@ export declare type double = number;
 /**
  * @public
  */
-export declare const EcsBoolean: EcsType<boolean>;
-
-/**
- * @public
- */
-declare type EcsResult<T extends EcsType> = T extends EcsType ? ReturnType<T['deserialize']> : never;
-
-/**
- * @public
- */
-export declare const EcsString: EcsType<string>;
-
-/**
- * @public
- */
-export declare type EcsType<T = any> = {
-    serialize(value: T, builder: ByteBuffer): void;
-    deserialize(reader: ByteBuffer): T;
-    create(): T;
-};
+declare type EcsResult<T extends ISchema> = T extends ISchema ? ReturnType<T['deserialize']> : never;
 
 /**
  * @public
@@ -302,57 +490,127 @@ export declare type Entity = number & {
 
 declare const entitySymbol: unique symbol;
 
-/**
- * @public
- */
-export declare function Enum<T>(type: EcsType<any>): EcsType<T>;
-
 /**
  * Constant used to define the minimal number value in Babylon.js
  * @public
  */
 export declare const Epsilon = 0.000001;
 
+export declare const error: (message: string | Error, data?: any) => void;
+
 /** Excludes property keys from T where the property is assignable to U */
 declare type ExcludeUndefined<T> = {
     [P in keyof T]: undefined extends T[P] ? never : P;
 }[keyof T];
 
-/**
- * @public
- */
-export declare const FlatString: EcsType<string>;
-
 /** @public */
 export declare type float = number;
 
-/**
- * @public
- */
-export declare const Float32: EcsType<number>;
+/** @public */
+export declare type FloatArray = number[];
+
+/** @public */
+export declare const GLTFShape: ComponentDefinition<ISchema<PBGLTFShape>>;
 
 /**
  * @public
  */
-export declare const Float64: EcsType<number>;
-
-/** @public */
-export declare type FloatArray = number[];
+declare function IArray<T>(type: ISchema<T>): ISchema<Array<T>>;
 
 /**
  * @public
  */
 export declare type IEngine = {
+    /**
+     * Increment the used entity counter and return the next one.
+     * @param dynamic
+     * @return the next entity unused
+     */
     addEntity(dynamic?: boolean): Entity;
+    /**
+     * An alias of engine.addEntity(true)
+     */
     addDynamicEntity(): Entity;
+    /**
+     * Remove all components of an entity
+     * @param entity
+     */
     removeEntity(entity: Entity): void;
+    /**
+     * Add the system to the engine. It will be called every tick updated.
+     * @param system function that receives the delta time between last tick and current one.
+     * @param priority a number with the priority, big number are called before smaller ones
+     * @param name optional: a unique name to identify it
+     *
+     * Example:
+     * ```ts
+     * function mySystem(dt: number) {
+     *   const entitiesWithBoxShapes = engine.getEntitiesWith(BoxShape, Transform)
+     *   for (const [entity, _boxShape, _transform] of engine.getEntitiesWith(BoxShape, Transform)) {
+     *     // do stuffs
+     *   }
+     * }
+     * engine.addSystem(mySystem, 10)
+     * ```
+     */
     addSystem(system: Update, priority?: number, name?: string): void;
+    /**
+     * Remove a system from the engine.
+     * @param selector the function or the unique name to identify
+     * @returns if it was found and removed
+     */
     removeSystem(selector: string | Update): boolean;
-    defineComponent<T extends EcsType>(componentId: number, spec: T): ComponentDefinition<T>;
-    mutableGroupOf<T extends [ComponentDefinition, ...ComponentDefinition[]]>(...components: T): Iterable<[Entity, ...ComponentEcsType<T>]>;
-    groupOf<T extends [ComponentDefinition, ...ComponentDefinition[]]>(...components: T): Iterable<[Entity, ...DeepReadonly<ComponentEcsType<T>>]>;
-    getComponent<T extends EcsType>(componentId: number): ComponentDefinition<T>;
-    update(dt: number): void;
+    /**
+     * Define a component and add it to the engine.
+     * @param spec An object with schema fields
+     * @param componentId unique id to identify the component, if the component id already exist, it will fail.
+     * @return The component definition
+     *
+     * ```ts
+     * const DoorComponentId = 10017
+     * const Door = engine.defineComponent({
+     *   id: Schemas.Int,
+     *   name: Schemas.String
+     * }, DoorComponentId)
+     *
+     * ```
+     */
+    defineComponent<T extends Spec>(spec: Spec, componentId: number): ComponentDefinition<ISchema<Result<T>>>;
+    /**
+     * Define a component and add it to the engine.
+     * @param spec An object with schema fields
+     * @param componentId unique id to identify the component, if the component id already exist, it will fail.
+     * @return The component definition
+     *
+     * ```ts
+     * const StateComponentId = 10023
+     * const StateComponent = engine.defineComponent(Schemas.Bool, VisibleComponentId)
+     * ```
+     */
+    defineComponentFromSchema<T extends ISchema>(spec: T, componentId: number): ComponentDefinition<T>;
+    /**
+     * Get the component definition from the component id.
+     * @param componentId
+     * @return the component definition, throw an error if it doesn't exist
+     * ```ts
+     * const StateComponentId = 10023
+     * const StateComponent = engine.getComponent(StateComponentId)
+     * ```
+     */
+    getComponent<T extends ISchema>(componentId: number): ComponentDefinition<T>;
+    /**
+     * Get a iterator of entities that has all the component requested.
+     * @param components a list of component definitions
+     * @return An iterator of an array with the [entity, component1, component2, ...]
+     *
+     * Example:
+     * ```ts
+     * for (const [entity, boxShape, transform] of engine.getEntitiesWith(BoxShape, Transform)) {
+     * // the properties of boxShape and transform are read only
+     * }
+     * ```
+     */
+    getEntitiesWith<T extends [ComponentDefinition, ...ComponentDefinition[]]>(...components: T): Iterable<[Entity, ...DeepReadonly<ComponentSchema<T>>]>;
     baseComponents: SdkComponents;
 };
 
@@ -363,30 +621,34 @@ export declare type IEngineParams = {
     transports?: Transport[];
 };
 
-/** Include property keys from T where the property is assignable to U */
-declare type IncludeUndefined<T> = {
-    [P in keyof T]: undefined extends T[P] ? P : never;
-}[keyof T];
-
 /**
  * @public
  */
-export declare const Int16: EcsType<number>;
+declare function IEnum<T>(type: ISchema<any>): ISchema<T>;
 
 /**
  * @public
  */
-export declare const Int32: EcsType<number>;
+declare function IMap<T extends Spec>(spec: T): ISchema<Result<T>>;
+
+/** Include property keys from T where the property is assignable to U */
+declare type IncludeUndefined<T> = {
+    [P in keyof T]: undefined extends T[P] ? P : never;
+}[keyof T];
 
 /**
  * @public
  */
-export declare const Int64: EcsType<number>;
+declare function IOptional<T>(spec: ISchema<T>): ISchema<T | undefined>;
 
 /**
  * @public
  */
-export declare const Int8: EcsType<number>;
+declare type ISchema<T = any> = {
+    serialize(value: T, builder: ByteBuffer): void;
+    deserialize(reader: ByteBuffer): T;
+    create(): T;
+};
 
 /**
  * Interface for the size containing width and height
@@ -403,10 +665,7 @@ export declare interface ISize {
     height: number;
 }
 
-/**
- * @public
- */
-export declare function MapType<T extends Spec>(spec: T): EcsType<Result<T>>;
+export declare const log: (...a: any[]) => void;
 
 /**
  * Class used to store matrix data (4x4)
@@ -1127,6 +1386,9 @@ declare namespace Matrix {
     function toggleProjectionMatrixHandInPlace(self: MutableMatrix): void;
 }
 
+/** @public */
+export declare const NFTShape: ComponentDefinition<ISchema<PBNFTShape>>;
+
 /** @public */
 export declare type Nullable<T> = T | null;
 
@@ -1138,10 +1400,17 @@ declare type OnlyOptionalUndefinedTypes<T> = {
     [K in IncludeUndefined<T>]?: T[K];
 };
 
-/**
- * @public
- */
-export declare function Optional<T>(spec: EcsType<T>): EcsType<T | undefined>;
+/** @public */
+export declare const OnPointerDown: ComponentDefinition<ISchema<PBOnPointerDown>>;
+
+/** @public */
+export declare const OnPointerDownResult: ComponentDefinition<ISchema<PBOnPointerDownResult>>;
+
+/** @public */
+export declare const OnPointerUp: ComponentDefinition<ISchema<PBOnPointerUp>>;
+
+/** @public */
+export declare const OnPointerUpResult: ComponentDefinition<ISchema<PBOnPointerUpResult>>;
 
 /**
  * Defines potential orientation for back face culling
@@ -1159,11 +1428,14 @@ export declare enum Orientation {
 declare interface PBAnimationState {
     name: string;
     clip: string;
-    playing: boolean;
-    weight: number;
-    speed: number;
-    loop: boolean;
-    shouldReset: boolean;
+    playing?: boolean | undefined;
+    /** default=1.0s */
+    weight?: number | undefined;
+    /** default=1.0 */
+    speed?: number | undefined;
+    /** default=true */
+    loop?: boolean | undefined;
+    shouldReset?: boolean | undefined;
 }
 
 declare interface PBAnimator {
@@ -1171,10 +1443,12 @@ declare interface PBAnimator {
 }
 
 declare interface PBAudioSource {
-    playing: boolean;
-    volume: number;
-    loop: boolean;
-    pitch: number;
+    playing?: boolean | undefined;
+    /** default=1.0f */
+    volume?: number | undefined;
+    loop?: boolean | undefined;
+    /** default=1.0f */
+    pitch?: number | undefined;
     audioClipUrl: string;
 }
 
@@ -1185,29 +1459,35 @@ declare interface PBAvatarAttach {
 
 declare interface PBAvatarShape {
     id: string;
-    name: string;
-    bodyShape: string;
-    skinColor: Color3 | undefined;
-    hairColor: Color3 | undefined;
-    eyeColor: Color3 | undefined;
+    name?: string | undefined;
+    bodyShape?: string | undefined;
+    skinColor?: Color3 | undefined;
+    hairColor?: Color3 | undefined;
+    eyeColor?: Color3 | undefined;
     wearables: string[];
-    expressionTriggerId: string;
-    expressionTriggerTimestamp: number;
-    stickerTriggerId: string;
-    stickerTriggerTimestamp: number;
-    talking: boolean;
+    expressionTriggerId?: string | undefined;
+    expressionTriggerTimestamp?: number | undefined;
+    stickerTriggerId?: string | undefined;
+    stickerTriggerTimestamp?: number | undefined;
+    talking?: boolean | undefined;
 }
 
 declare interface PBBillboard {
-    x: boolean;
-    y: boolean;
-    z: boolean;
+    /** default=true */
+    x?: boolean | undefined;
+    /** default=true */
+    y?: boolean | undefined;
+    /** default=true */
+    z?: boolean | undefined;
 }
 
 declare interface PBBoxShape {
-    withCollisions: boolean;
-    isPointerBlocker: boolean;
-    visible: boolean;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    withCollisions?: boolean | undefined;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    isPointerBlocker?: boolean | undefined;
+    /** @deprecated use HiddenComponent instead https://github.com/decentraland/sdk/issues/353 */
+    visible?: boolean | undefined;
     uvs: number[];
 }
 
@@ -1221,35 +1501,50 @@ declare interface PBCameraModeArea {
 }
 
 declare interface PBCylinderShape {
-    withCollisions: boolean;
-    isPointerBlocker: boolean;
-    visible: boolean;
-    radiusTop: number;
-    radiusBottom: number;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    withCollisions?: boolean | undefined;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    isPointerBlocker?: boolean | undefined;
+    /** @deprecated use HiddenComponent instead https://github.com/decentraland/sdk/issues/353 */
+    visible?: boolean | undefined;
+    /** default=1.0 */
+    radiusTop?: number | undefined;
+    /** default=1.0 */
+    radiusBottom?: number | undefined;
 }
 
 declare interface PBGLTFShape {
-    withCollisions: boolean;
-    isPointerBlocker: boolean;
-    visible: boolean;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    withCollisions?: boolean | undefined;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    isPointerBlocker?: boolean | undefined;
+    /** @deprecated use HiddenComponent instead https://github.com/decentraland/sdk/issues/353 */
+    visible?: boolean | undefined;
     src: string;
 }
 
 declare interface PBNFTShape {
-    withCollisions: boolean;
-    isPointerBlocker: boolean;
-    visible: boolean;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    withCollisions?: boolean | undefined;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    isPointerBlocker?: boolean | undefined;
+    /** @deprecated use HiddenComponent instead https://github.com/decentraland/sdk/issues/353 */
+    visible?: boolean | undefined;
     src: string;
-    assetId: string;
-    style: number;
-    color: Color3 | undefined;
+    assetId?: string | undefined;
+    style?: number | undefined;
+    color?: Color3 | undefined;
 }
 
 declare interface PBOnPointerDown {
-    button: ActionButton;
-    hoverText: string;
-    distance: number;
-    showFeedback: boolean;
+    /** default=ActionButton.ANY */
+    button?: ActionButton | undefined;
+    /** default='Interact' */
+    hoverText?: string | undefined;
+    /** default=10 */
+    maxDistance?: number | undefined;
+    /** default=true */
+    showFeedback?: boolean | undefined;
 }
 
 declare interface PBOnPointerDownResult {
@@ -1264,10 +1559,14 @@ declare interface PBOnPointerDownResult {
 }
 
 declare interface PBOnPointerUp {
-    button: ActionButton;
-    hoverText: string;
-    distance: number;
-    showFeedback: boolean;
+    /** default=ActionButton.ANY */
+    button?: ActionButton | undefined;
+    /** default='Interact' */
+    hoverText?: string | undefined;
+    /** default=10 */
+    maxDistance?: number | undefined;
+    /** default=true */
+    showFeedback?: boolean | undefined;
 }
 
 declare interface PBOnPointerUpResult {
@@ -1282,9 +1581,12 @@ declare interface PBOnPointerUpResult {
 }
 
 declare interface PBPlaneShape {
-    withCollisions: boolean;
-    isPointerBlocker: boolean;
-    visible: boolean;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    withCollisions?: boolean | undefined;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    isPointerBlocker?: boolean | undefined;
+    /** @deprecated use HiddenComponent instead https://github.com/decentraland/sdk/issues/353 */
+    visible?: boolean | undefined;
     uvs: number[];
 }
 
@@ -1293,36 +1595,49 @@ declare interface PBPointerLock {
 }
 
 declare interface PBSphereShape {
-    withCollisions: boolean;
-    isPointerBlocker: boolean;
-    visible: boolean;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    withCollisions?: boolean | undefined;
+    /** @deprecated use MeshCollider instead https://github.com/decentraland/sdk/issues/366 */
+    isPointerBlocker?: boolean | undefined;
+    /** @deprecated use HiddenComponent instead https://github.com/decentraland/sdk/issues/353 */
+    visible?: boolean | undefined;
 }
 
 declare interface PBTextShape {
     text: string;
-    visible: boolean;
-    font: string;
-    opacity: number;
-    fontSize: number;
-    fontAutoSize: boolean;
-    hTextAlign: string;
-    vTextAlign: string;
-    width: number;
-    height: number;
-    paddingTop: number;
-    paddingRight: number;
-    paddingBottom: number;
-    paddingLeft: number;
-    lineSpacing: number;
-    lineCount: number;
-    textWrapping: boolean;
-    shadowBlur: number;
-    shadowOffsetX: number;
-    shadowOffsetY: number;
-    outlineWidth: number;
-    shadowColor: Color3 | undefined;
-    outlineColor: Color3 | undefined;
-    textColor: Color3 | undefined;
+    /** @deprecated use HiddenComponent instead https://github.com/decentraland/sdk/issues/353 */
+    visible?: boolean | undefined;
+    font?: string | undefined;
+    /** default=1.0f */
+    opacity?: number | undefined;
+    /** default=10 */
+    fontSize?: number | undefined;
+    fontAutoSize?: boolean | undefined;
+    /** default='center' */
+    hTextAlign?: string | undefined;
+    /** default='center' */
+    vTextAlign?: string | undefined;
+    /** default=1 */
+    width?: number | undefined;
+    /** default=1 */
+    height?: number | undefined;
+    paddingTop?: number | undefined;
+    paddingRight?: number | undefined;
+    paddingBottom?: number | undefined;
+    paddingLeft?: number | undefined;
+    lineSpacing?: number | undefined;
+    lineCount?: number | undefined;
+    textWrapping?: boolean | undefined;
+    shadowBlur?: number | undefined;
+    shadowOffsetX?: number | undefined;
+    shadowOffsetY?: number | undefined;
+    outlineWidth?: number | undefined;
+    /** default=(1.0,1.0,1.0) */
+    shadowColor?: Color3 | undefined;
+    /** default=(1.0,1.0,1.0) */
+    outlineColor?: Color3 | undefined;
+    /** default=(1.0,1.0,1.0) */
+    textColor?: Color3 | undefined;
 }
 
 /**
@@ -1434,6 +1749,12 @@ declare namespace Plane {
     function signedDistanceTo(plane: ReadonlyPlane, point: Vector3.ReadonlyVector3): number;
 }
 
+/** @public */
+export declare const PlaneShape: ComponentDefinition<ISchema<PBPlaneShape>>;
+
+/** @public */
+export declare const PointerLock: ComponentDefinition<ISchema<PBPointerLock>>;
+
 /**
  * @public
  */
@@ -1618,13 +1939,33 @@ declare type ReceiveMessage = {
  * @public
  */
 export declare type Result<T extends Spec> = ToOptional<{
-    [K in keyof T]: T[K] extends EcsType ? ReturnType<T[K]['deserialize']> : T[K] extends Spec ? Result<T[K]> : never;
+    [K in keyof T]: T[K] extends ISchema ? ReturnType<T[K]['deserialize']> : T[K] extends Spec ? Result<T[K]> : never;
 }>;
 
 /**
  * @public
  */
-export declare type SdkComponents = ReturnType<typeof defineSdkComponents>;
+export declare namespace Schemas {
+    export type SchemaType = ISchema;
+    const Boolean: ISchema<boolean>;
+    const String: ISchema<string>;
+    const Float: ISchema<number>;
+    const Double: ISchema<number>;
+    const Byte: ISchema<number>;
+    const Short: ISchema<number>;
+    const Int: ISchema<number>;
+    const Int64: ISchema<number>;
+    const Number: ISchema<number>;
+    const Enum: typeof IEnum;
+    const Array: typeof IArray;
+    const Map: typeof IMap;
+    const Optional: typeof IOptional;
+}
+
+/**
+ * @public
+ */
+export declare type SdkComponents = ReturnType<typeof defineLibraryComponents>;
 
 /**
  * Defines supported spaces
@@ -1643,9 +1984,15 @@ export declare enum Space {
  * @public
  */
 export declare interface Spec {
-    [key: string]: EcsType;
+    [key: string]: ISchema;
 }
 
+/** @public */
+export declare const SphereShape: ComponentDefinition<ISchema<PBSphereShape>>;
+
+/** @public */
+export declare const TextShape: ComponentDefinition<ISchema<PBTextShape>>;
+
 /**
  * Constant used to convert a value to gamma space
  * @public
@@ -1660,26 +2007,35 @@ export declare const ToLinearSpace = 2.2;
 
 declare type ToOptional<T> = OnlyOptionalUndefinedTypes<T> & OnlyNonUndefinedTypes<T>;
 
-/**
- * @public
- */
-declare type Transform = {
-    position: Vector3.MutableVector3;
-    rotation: Quaternion.MutableQuaternion;
-    scale: Vector3.MutableVector3;
-    parent?: Entity;
+/** @public */
+export declare const Transform: ComponentDefinition<ISchema<    {
+position: {
+x: number;
+y: number;
+z: number;
 };
+rotation: {
+x: number;
+y: number;
+z: number;
+w: number;
+};
+scale: {
+x: number;
+y: number;
+z: number;
+};
+parent?: Entity | undefined;
+}>>;
 
-declare const Transform: EcsType<Transform>;
-
-declare type Transport = {
+export declare type Transport = {
     type: string;
     send(message: Uint8Array): void;
     onmessage?(message: Uint8Array): void;
     filter(message: Omit<TransportMessage, 'messageBuffer'>): boolean;
 };
 
-declare type TransportMessage = Omit<ReceiveMessage, 'data'>;
+export declare type TransportMessage = Omit<ReceiveMessage, 'data'>;
 
 declare type Uint32 = number;
 
@@ -1691,7 +2047,7 @@ export declare type Unpacked<T> = T extends (infer U)[] ? U : T;
 /**
  * @public
  */
-declare type Update = (dt: number) => void;
+export declare type Update = (dt: number) => void;
 
 /**
  * @public