@webspatial/core-sdk 1.0.4 → 1.0.5

package/dist/index.d.ts

@@ -1,225 +1,216 @@
-type WindowStyle = 'Plain' | 'Volumetric';
-interface WindowContainerOptions {
-    defaultSize?: {
-        width: number;
-        height: number;
-    };
-    resizability?: {
-        minWidth?: number;
-        minHeight?: number;
-        maxWidth?: number;
-        maxHeight?: number;
-    };
-}
-type LoadingMethodKind = 'show' | 'hide';
-interface sceneDataShape {
-    method?: 'createRoot' | 'showRoot';
-    sceneConfig?: WindowContainerOptions;
-    url?: string;
-    window: Window;
-}
-interface sceneDataJSBShape {
-    method?: 'createRoot' | 'showRoot';
-    sceneConfig?: WindowContainerOptions;
-    url?: string;
-    windowID?: string;
-    windowContainerID?: string;
-}
-
-declare global {
-    interface Window {
-        __WebSpatialData: {
-            androidNativeMessage: Function;
-            getNativeVersion: Function;
-        };
-        __SpatialWebEvent: Function;
-        webkit: any;
-        __WebSpatialUnloaded: boolean;
-        _webSpatialID: string;
-        _webSpatialGroupID: string;
-        _webSpatialParentGroupID: string;
-        WebSpatailNativeVersion: string;
-    }
-}
-declare class WindowContainer {
-    id: string;
-}
-declare class WebSpatialResource {
-    id: string;
-    windowContainerId: string;
-    data: any;
-    receiveEvent(): void;
-}
-
 /**
  * @hidden
  * Parent class of spatial objects, should not be used directly
  */
 declare class SpatialObject {
     /** @hidden */
-    _resource: WebSpatialResource;
+    readonly id: string;
     /** @hidden */
     constructor(
     /** @hidden */
-    _resource: WebSpatialResource);
-    /**
-     * Marks resource to be released (it should no longer be used)
-     */
-    destroy(): Promise<void>;
-    name: string;
-    protected onDestroy(): Promise<void>;
+    id: string);
+    name?: string;
+    isDestroyed: boolean;
+    inspect(): Promise<any>;
+    destroy(): Promise<any>;
+    protected onDestroy(): void;
 }
 
-declare class Vec3 {
-    x: number;
-    y: number;
-    z: number;
-    constructor(x?: number, y?: number, z?: number);
+interface CommandResult {
+    success: boolean;
+    data: any;
+    errorCode: string | undefined;
+    errorMessage: string | undefined;
 }
-declare class Vec4 {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-    constructor(x?: number, y?: number, z?: number, w?: number);
+interface WebSpatialProtocolResult extends CommandResult {
+    success: boolean;
+    data: {
+        windowProxy: WindowProxy;
+        id: string;
+    } | undefined;
+    errorCode: string | undefined;
+    errorMessage: string | undefined;
 }
-/**
- * Transform containing position, orientation and scale
- */
-declare class SpatialTransform {
-    position: Vec3;
-    /** Quaternion value for x,y,z,w */
-    orientation: Vec4;
-    scale: Vec3;
+
+declare class SpatialGeometry extends SpatialObject {
+    id: string;
+    options: SpatialGeometryOptions;
+    static type: SpatialGeometryType;
+    constructor(id: string, options: SpatialGeometryOptions);
 }
 
-/**
- * Anchored window managed by the OS
- */
-declare class SpatialWindowContainer {
-    /** @hidden */
-    _wg: WindowContainer;
-    /** @hidden */
-    constructor(
-    /** @hidden */
-    _wg: WindowContainer);
-    /**
-     * @hidden
-     * Sets sets the open configuration for opening new window containers
-     * @param options style options
-     */
-    _setOpenSettings(options: {
-        resolution: {
-            width: number;
-            height: number;
-        };
-    }): Promise<void>;
-    /**
-     * Retrieves the root entity of the windowContainer
-     * @returns the root entity of the windowContainer if one exists
-     */
-    getRootEntity(): Promise<SpatialEntity | null>;
-    setRootEntity(entity: SpatialEntity): Promise<void>;
-    close(): Promise<void>;
+declare abstract class SpatialMaterial extends SpatialObject {
+    id: string;
+    type: SpatialMaterialType;
+    constructor(id: string, type: SpatialMaterialType);
+    abstract updateProperties(properties: any): void;
+}
+
+declare enum SpatialWebMsgType {
+    cubeInfo = "cubeInfo",
+    transform = "transform",
+    modelloaded = "modelloaded",
+    modelloadfailed = "modelloadfailed",
+    spatialtap = "spatialtap",
+    spatialdragstart = "spatialdragstart",
+    spatialdrag = "spatialdrag",
+    spatialdragend = "spatialdragend",
+    spatialrotatestart = "spatialrotatestart",
+    spatialrotate = "spatialrotate",
+    spatialrotateend = "spatialrotateend",
+    spatialmagnifystart = "spatialmagnifystart",
+    spatialmagnify = "spatialmagnify",
+    spatialmagnifyend = "spatialmagnifyend",
+    objectdestroy = "objectdestroy"
+}
+interface ObjectDestroyMsg {
+    type: SpatialWebMsgType.objectdestroy;
+}
+interface CubeInfoMsg {
+    type: SpatialWebMsgType.cubeInfo;
+    origin: Vec3;
+    size: Size3D;
+}
+interface CubeInfoMsg {
+    type: SpatialWebMsgType.cubeInfo;
+    origin: Vec3;
+    size: Size3D;
+}
+interface TransformMsg {
+    type: SpatialWebMsgType.transform;
+    detail: {
+        column0: [number, number, number];
+        column1: [number, number, number];
+        column2: [number, number, number];
+        column3: [number, number, number];
+    };
+}
+interface SpatialTapMsg {
+    type: SpatialWebMsgType.spatialtap;
+    detail: SpatialTapEventDetail;
+}
+interface SpatialDragMsg {
+    type: SpatialWebMsgType.spatialdrag;
+    detail: SpatialDragEventDetail;
+}
+interface SpatialDragEndMsg {
+    type: SpatialWebMsgType.spatialdragend;
+    detail: SpatialDragEventDetail;
+}
+interface SpatialRotateMsg {
+    type: SpatialWebMsgType.spatialrotate;
+    detail: SpatialRotateEventDetail;
+}
+interface SpatialRotateEndMsg {
+    type: SpatialWebMsgType.spatialrotateend;
+    detail: SpatialRotateEventDetail;
 }
 
 /**
- * Entity used to describe an object that can be added to the scene
+ * Abstract base class for all spatialized elements in the WebSpatial environment.
+ * Provides common functionality for elements that can exist in 3D space,
+ * including transformation handling and gesture event processing.
  */
-declare class SpatialEntity extends SpatialObject {
+declare abstract class SpatializedElement extends SpatialObject {
+    readonly id: string;
     /**
-     * Transform corresponding to the entity
-     * note: updateTransform must be called for transform to be synced to rendering
+     * Creates a new spatialized element with the specified ID.
+     * Registers the element to receive spatial events.
+     * @param id Unique identifier for this element
      */
-    transform: SpatialTransform;
-    /** @hidden */
-    private _destroyed;
-    /** @hidden */
-    private get _entity();
+    constructor(id: string);
     /**
-     * Syncs the transform with the renderer, must be called to observe updates
+     * Updates the properties of this spatialized element.
+     * Must be implemented by derived classes to handle specific property updates.
+     * @param properties Partial set of properties to update
+     * @returns Promise resolving to the result of the update operation
      */
-    updateTransform(): Promise<void>;
+    abstract updateProperties(properties: Partial<SpatializedElementProperties>): Promise<WebSpatialProtocolResult>;
     /**
-     * Syncs the zIndex with the renderer
+     * Updates the transformation matrix of this element in 3D space.
+     * This affects the position, rotation, and scale of the element.
+     * @param matrix The new transformation matrix
+     * @returns Promise resolving when the transform is updated
      */
-    updateZIndex(zIndex: number): Promise<void>;
-    private components;
+    updateTransform(matrix: DOMMatrix): Promise<CommandResult>;
     /**
-     * Attaches a component to the entity to be displayed
-     * [TODO] review pass by value vs ref and ownership model for this
+     * Information about the element's bounding cube.
+     * Used for spatial calculations and hit testing.
      */
-    setComponent(component: SpatialComponent): Promise<void>;
+    private _cubeInfo?;
     /**
-     * Removes a component from the entity
+     * Gets the current cube information for this element.
+     * @returns The current CubeInfo or undefined if not set
      */
-    removeComponent<T extends SpatialComponent>(type: new (...args: any[]) => T): Promise<void>;
+    get cubeInfo(): CubeInfo$1 | undefined;
     /**
-     * Gets a component from the entity
+     * The current transformation matrix of this element.
      */
-    getComponent<T extends SpatialComponent>(type: new (...args: any[]) => T): T | undefined;
+    private _transform?;
     /**
-     * @hidden
-     * Sets the window container that this entity should be rendered by (this does not effect resource ownership)
-     * @param wg the window container that should render this entity
+     * The inverse of the current transformation matrix.
+     * Used for converting world coordinates to local coordinates.
      */
-    _setParentWindowContainer(wg: SpatialWindowContainer): Promise<void>;
+    private _transformInv?;
     /**
-     * Sets a parent entity, if that entity or its parents are attached to a window container, this entity will be displayed
-     * @param e parent entity or null to remove current parent
+     * Gets the current transformation matrix.
+     * @returns The current transformation matrix or undefined if not set
      */
-    setParent(e: SpatialEntity | null): Promise<void>;
+    get transform(): DOMMatrix | undefined;
     /**
-     * Sets the coordinate space of this entity (Default: App)
-     * "App" = game engine style coordinates in meters
-     * "Dom" = Windowing coordinates in dom units (eg. 0,0,0 is top left of window)
-     * "Root" = Coordinate space is ignored and content is displayed and updated as window container's root object, window containers can only have one root entity
-     * [TODO] review this api
-     * @param space coordinate space mode
+     * Gets the inverse of the current transformation matrix.
+     * @returns The inverse transformation matrix or undefined if not set
      */
-    setCoordinateSpace(space: 'App' | 'Dom' | 'Root'): Promise<void>;
+    get transformInv(): DOMMatrix | undefined;
     /**
-     * Query the 3d boudning box of the entity
-     * @returns The bounding box of the entity
+     * Processes events received from the WebSpatial environment.
+     * Handles various spatial events like transforms, gestures, and interactions.
+     * @param data The event data received from the WebSpatial system
      */
-    getBoundingBox(): Promise<{
-        center: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        extents: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    }>;
+    protected onReceiveEvent(data: CubeInfoMsg | TransformMsg | SpatialTapMsg | SpatialDragMsg | SpatialDragEndMsg | SpatialRotateMsg | SpatialRotateEndMsg | ObjectDestroyMsg): void;
+    private _onSpatialTap?;
+    set onSpatialTap(value: (event: SpatialTapEvent) => void | undefined);
+    private _isDragging;
+    private _onSpatialDragStart?;
+    set onSpatialDragStart(value: (event: SpatialDragEvent) => void | undefined);
+    private _onSpatialDrag?;
+    set onSpatialDrag(value: (event: SpatialDragEvent) => void | undefined);
+    private _onSpatialDragEnd?;
+    set onSpatialDragEnd(value: ((event: SpatialDragEndEvent) => void) | undefined);
+    private _isRotating;
+    private _onSpatialRotateStart?;
+    set onSpatialRotateStart(value: ((event: SpatialRotateEvent) => void) | undefined);
+    private _onSpatialRotate?;
+    set onSpatialRotate(value: ((event: SpatialRotateEvent) => void) | undefined);
+    private _onSpatialRotateEnd?;
+    set onSpatialRotateEnd(value: ((event: SpatialRotateEndEvent) => void) | undefined);
+    private _isMagnify;
+    private _onSpatialMagnifyStart?;
+    set onSpatialMagnifyStart(value: ((event: SpatialMagnifyEvent) => void) | undefined);
+    private _onSpatialMagnify?;
+    set onSpatialMagnify(value: ((event: SpatialMagnifyEvent) => void) | undefined);
+    private _onSpatialMagnifyEnd?;
+    set onSpatialMagnifyEnd(value: ((event: SpatialMagnifyEndEvent) => void) | undefined);
     /**
-     * Sets if the entity should be visible (default: True)
-     * @param visible
+     * Cleans up resources when this element is destroyed.
+     * Removes event receivers to prevent memory leaks.
      */
-    setVisible(visible: boolean): Promise<void>;
-    /**
-     * Removes a reference to the entity by the renderer and this object should no longer be used. [TODO] Attached components will not be destroyed
-     */
-    destroy(): Promise<void>;
-    /**
-     * Check if destroy has been called
-     */
-    isDestroyed(): boolean;
-    /** @hidden */
-    _setName(name: string): Promise<unknown>;
+    onDestroy(): void;
 }
 
-/** @hidden */
-declare class SpatialComponent extends SpatialObject {
-    /**
-     * Gets the entity this component is attached to
-     * @returns entity or null
-     */
-    getEntity(): Promise<SpatialEntity | null>;
+declare class SpatializedDynamic3DElement extends SpatializedElement {
+    children: SpatialEntityOrReality[];
+    constructor(id: string);
+    addEntity(entity: SpatialEntity): Promise<CommandResult>;
+    updateProperties(properties: Partial<SpatializedElementProperties>): Promise<CommandResult>;
 }
 
+interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+type Point3D = Vec3;
 /**
  * Material type for SpatialDiv or HTML document.
  *
@@ -241,500 +232,631 @@ type CornerRadius = {
     topTrailing: number;
     bottomTrailing: number;
 };
-type StyleParam = {
-    material?: {
-        type: BackgroundMaterialType;
+interface SpatialSceneProperties {
+    cornerRadius: CornerRadius;
+    material: BackgroundMaterialType;
+    opacity: number;
+}
+declare enum SpatializedElementType {
+    Spatialized2DElement = 0,
+    SpatializedStatic3DElement = 1,
+    SpatializedDynamic3DElement = 2
+}
+interface SpatializedElementProperties {
+    name: string;
+    clientX: number;
+    clientY: number;
+    width: number;
+    height: number;
+    depth: number;
+    opacity: number;
+    visible: boolean;
+    scrollWithParent: boolean;
+    zIndex: number;
+    backOffset: number;
+    rotationAnchor: Point3D;
+    enableTapGesture: boolean;
+    enableDragStartGesture: boolean;
+    enableDragGesture: boolean;
+    enableDragEndGesture: boolean;
+    enableRotateStartGesture: boolean;
+    enableRotateGesture: boolean;
+    enableRotateEndGesture: boolean;
+    enableMagnifyStartGesture: boolean;
+    enableMagnifyGesture: boolean;
+    enableMagnifyEndGesture: boolean;
+}
+interface Spatialized2DElementProperties extends SpatializedElementProperties {
+    scrollPageEnabled: boolean;
+    cornerRadius: CornerRadius;
+    material: BackgroundMaterialType;
+    scrollEdgeInsetsMarginRight: number;
+}
+interface SpatializedStatic3DElementProperties extends SpatializedElementProperties {
+    modelURL: string;
+    modelTransform?: number[];
+}
+interface SpatialSceneCreationOptions$1 {
+    defaultSize?: {
+        width: number | string;
+        height: number | string;
+        depth?: number | string;
     };
-    cornerRadius?: number | CornerRadius;
-};
-/**
- * Used to position an web window in 3D space
- */
-declare class SpatialWindowComponent extends SpatialComponent {
-    /**
-     * Loads a url page in the window
-     * @param url url to load
-     */
-    loadURL(url: string): Promise<void>;
-    setFromWindow(window: any): Promise<void>;
-    /**
-     * Sets the resolution of the window, the resulting dimensions when rendered will be equal to 1/1360 units
-     * eg. if the resolution is set to 1360x1360 it will be a 1x1 plane
-     * See 1360 in spatialViewUI.swift for how this ratio works
-     * @param width width in pixels
-     * @param height height in pixels
-     */
-    setResolution(width: number, height: number): Promise<void>;
-    /**
-     * [Experimental] Sets the anchor which the entity this is attached to will rotate around
-     * @param rotationAnchor
-     */
-    setRotationAnchor(rotationAnchor: Vec3): Promise<void>;
-    /**
-     * [Experimental] Sets the opacity of the window after apply material
-     * @param opacity
-     */
-    setOpacity(opacity: number): Promise<void>;
-    /**
-     * Sets the style that should be applied to the window
-     * @param options style options
-     */
-    setStyle(styleParam: StyleParam): Promise<void>;
-    /**
-     * Modifies the amount the spatial window can be scrolled
-     * Should only be used internally
-     * See https://developer.apple.com/documentation/uikit/1624475-uiedgeinsetsmake?language=objc
-     * @param insets margin to modify scroll distances by
-     */
-    setScrollEdgeInsets(insets: {
-        top: number;
-        left: number;
-        bottom: number;
-        right: number;
-    }): Promise<void>;
-    /**
-     * Enable/Disable scrolling in the window (defaults to enabled), if disabled, scrolling will be applied to the root page
-     * @param enabled value to set
-     */
-    setScrollEnabled(enabled: boolean): Promise<void>;
-    /**
-     * Defaults to false. If set to true, scrolling the parent page will also scroll this window with it like other dom elements
-     * @param scrollWithParent value to set
-     */
-    setScrollWithParent(scrollWithParent: boolean): Promise<void>;
+    resizability?: {
+        minWidth?: number | string;
+        minHeight?: number | string;
+        maxWidth?: number | string;
+        maxHeight?: number | string;
+    };
+    worldScaling?: WorldScalingType;
+    worldAlignment?: WorldAlignmentType;
+    baseplateVisibility?: BaseplateVisibilityType;
 }
-
+declare const BaseplateVisibilityValues: readonly ["automatic", "visible", "hidden"];
+type BaseplateVisibilityType = (typeof BaseplateVisibilityValues)[number];
+declare function isValidBaseplateVisibilityType(type: string): Boolean;
+declare const WorldScalingValues: readonly ["automatic", "dynamic"];
+type WorldScalingType = (typeof WorldScalingValues)[number];
+declare function isValidWorldScalingType(type: string): Boolean;
+declare const WorldAlignmentValues: readonly ["adaptive", "automatic", "gravityAligned"];
+type WorldAlignmentType = (typeof WorldAlignmentValues)[number];
+declare function isValidWorldAlignmentType(type: string): Boolean;
+declare const SpatialSceneValues: readonly ["window", "volume"];
+type SpatialSceneType$1 = (typeof SpatialSceneValues)[number];
+declare function isValidSpatialSceneType(type: string): Boolean;
 /**
- * @description
- * Represents a spatial component that handles events related to spatial interactions.
- * This class extends `SpatialComponent` and provides additional functionality for managing
- * event-driven spatial behaviors.
+ * check px,m and number, number must be >= 0
  *
- * @hidden
- * This class is intended for internal use and should not be exposed in the public API.
- */
-declare abstract class EventSpatialComponent extends SpatialComponent {
-    constructor(_resource: WebSpatialResource);
-    /**
-     * @description
-     * Abstract method to be implemented by subclasses. Called when a spatial event is received.
-     * @param data The data associated with the received event.
-     */
-    protected abstract onRecvEvent(data: any): void;
-    protected onDestroy(): Promise<void>;
+ * */
+declare function isValidSceneUnit(val: string | number): boolean;
+interface SpatialEntityProperties {
+    position: Vec3;
+    rotation: Vec3;
+    scale: Vec3;
+}
+type SpatialEntityEventType = 'spatialtap';
+type SpatialGeometryType = 'BoxGeometry' | 'PlaneGeometry' | 'SphereGeometry' | 'CylinderGeometry' | 'ConeGeometry';
+interface SpatialBoxGeometryOptions {
+    width?: number;
+    height?: number;
+    depth?: number;
+    cornerRadius?: number;
+    splitFaces?: boolean;
+}
+interface SpatialPlaneGeometryOptions {
+    width?: number;
+    height?: number;
+    cornerRadius?: number;
+}
+interface SpatialSphereGeometryOptions {
+    radius?: number;
+}
+interface SpatialConeGeometryOptions {
+    radius?: number;
+    height?: number;
+}
+interface SpatialCylinderGeometryOptions {
+    radius?: number;
+    height?: number;
+}
+type SpatialGeometryOptions = SpatialBoxGeometryOptions | SpatialPlaneGeometryOptions | SpatialSphereGeometryOptions | SpatialCylinderGeometryOptions | SpatialConeGeometryOptions;
+type SpatialMaterialType = 'unlit';
+interface SpatialUnlitMaterialOptions {
+    color?: string;
+    textureId?: string;
+    transparent?: boolean;
+    opacity?: number;
+}
+interface ModelComponentOptions {
+    mesh: SpatialGeometry;
+    materials: SpatialMaterial[];
+}
+interface SpatialEntityUserData {
+    id?: string;
+    name?: string;
+}
+interface SpatialModelEntityCreationOptions {
+    modelAssetId: string;
+    name?: string;
+}
+interface ModelAssetOptions {
+    url: string;
+}
+declare enum SpatialSceneState$1 {
+    idle = "idle",
+    pending = "pending",
+    willVisible = "willVisible",
+    visible = "visible",
+    fail = "fail"
 }
-
 /**
  * Translate event, matching similar behavior to https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/drag_event
  */
-type TranslateEvent = {
+type SpatialModelDragEvent = {
     eventType: 'dragstart' | 'dragend' | 'drag';
-    translate?: Vec3;
+    translation3D: Vec3;
+    startLocation3D: Vec3;
 };
-/**
- * Used to handle input events on an entity
- */
-declare class SpatialInputComponent extends EventSpatialComponent {
-    protected onRecvEvent(data: any): void;
-    /**
-     * Callback fired when a translate event occurs
-     * @param data translate event data
-     */
-    onTranslate(data: TranslateEvent): void;
+interface Size {
+    width: number;
+    height: number;
+}
+interface Size3D extends Size {
+    depth: number;
+}
+declare class CubeInfo$1 {
+    size: Size3D;
+    origin: Vec3;
+    constructor(size: Size3D, origin: Vec3);
+    get x(): number;
+    get y(): number;
+    get z(): number;
+    get width(): number;
+    get height(): number;
+    get depth(): number;
+    get left(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    get back(): number;
+    get front(): number;
 }
+interface SpatialTapEventDetail {
+    location3D: Point3D;
+}
+type SpatialTapEvent = CustomEvent<SpatialTapEventDetail>;
+interface SpatialDragEventDetail {
+    location3D: Point3D;
+    startLocation3D: Point3D;
+    translation3D: Vec3;
+    predictedEndTranslation3D: Vec3;
+    predictedEndLocation3D: Point3D;
+    velocity: Size;
+}
+type SpatialDragEvent = CustomEvent<SpatialDragEventDetail>;
+type SpatialDragEndEvent = SpatialDragEvent;
+interface SpatialRotateEventDetail {
+    rotation: {
+        vector: [number, number, number, number];
+    };
+    startAnchor3D: Vec3;
+    startLocation3D: Point3D;
+}
+type SpatialRotateEvent = CustomEvent<SpatialRotateEventDetail>;
+type SpatialRotateEndEvent = SpatialRotateEvent;
+interface SpatialMagnifyEventDetail {
+    magnification: number;
+    velocity: number;
+    startAnchor3D: Vec3;
+    startLocation3D: Point3D;
+}
+type SpatialMagnifyEvent = CustomEvent<SpatialMagnifyEventDetail>;
+type SpatialMagnifyEndEvent = SpatialMagnifyEvent;
+type SpatialEntityOrReality = SpatialEntity | SpatializedDynamic3DElement;
 
-/**
- * Mesh asset containing geometry
- */
-declare class SpatialMeshResource extends SpatialObject {
+declare class SpatialComponent extends SpatialObject {
+    constructor(id: string);
+    private onReceiveEvent;
+}
+
+declare class SpatialEntity extends SpatialObject {
+    userData?: SpatialEntityUserData | undefined;
+    position: Vec3;
+    rotation: Vec3;
+    scale: Vec3;
+    events: Record<string, (data: any) => void>;
+    children: SpatialEntity[];
+    parent: SpatialEntityOrReality | null;
+    constructor(id: string, userData?: SpatialEntityUserData | undefined);
+    addComponent(component: SpatialComponent): Promise<CommandResult>;
+    setPosition(position: Vec3): Promise<CommandResult>;
+    setRotation(rotation: Vec3): Promise<CommandResult>;
+    setScale(scale: Vec3): Promise<CommandResult>;
+    addEntity(ent: SpatialEntity): Promise<CommandResult>;
+    removeFromParent(): Promise<CommandResult>;
+    updateTransform(properties: Partial<SpatialEntityProperties>): Promise<CommandResult>;
+    addEvent(type: SpatialEntityEventType, callback: (data: any) => void): Promise<void>;
+    removeEvent(eventName: SpatialEntityEventType): Promise<void>;
+    updateEntityEvent(eventName: SpatialEntityEventType, isEnable: boolean): Promise<CommandResult>;
+    private onReceiveEvent;
+    dispatchEvent(evt: CustomEvent): void;
+    protected onDestroy(): void;
+    convertFromEntityToEntity(fromEntityId: string, toEntityId: string, position: Vec3): Promise<CommandResult>;
+    convertFromEntityToScene(fromEntityId: string, position: Vec3): Promise<CommandResult>;
+    convertFromSceneToEntity(entityId: string, position: Vec3): Promise<CommandResult>;
+}
+
+declare class SpatialModelEntity extends SpatialEntity {
+    id: string;
+    options?: SpatialModelEntityCreationOptions | undefined;
+    userData?: SpatialEntityUserData | undefined;
+    constructor(id: string, options?: SpatialModelEntityCreationOptions | undefined, userData?: SpatialEntityUserData | undefined);
+}
+
+declare class ModelComponent extends SpatialComponent {
+    options: ModelComponentOptions;
+    constructor(id: string, options: ModelComponentOptions);
+}
+
+declare class SpatialUnlitMaterial extends SpatialMaterial {
+    id: string;
+    options: SpatialUnlitMaterialOptions;
+    constructor(id: string, options: SpatialUnlitMaterialOptions);
+    updateProperties(properties: Partial<SpatialUnlitMaterialOptions>): Promise<CommandResult>;
+}
+
+declare class SpatialBoxGeometry extends SpatialGeometry {
+    id: string;
+    options: SpatialBoxGeometryOptions;
+    static type: SpatialGeometryType;
+    constructor(id: string, options: SpatialBoxGeometryOptions);
+}
+
+declare class SpatialSphereGeometry extends SpatialGeometry {
+    id: string;
+    options: SpatialSphereGeometryOptions;
+    static type: SpatialGeometryType;
+    constructor(id: string, options: SpatialSphereGeometryOptions);
+}
+
+declare class SpatialCylinderGeometry extends SpatialGeometry {
+    id: string;
+    options: SpatialCylinderGeometryOptions;
+    static type: SpatialGeometryType;
+    constructor(id: string, options: SpatialCylinderGeometryOptions);
+}
+
+declare class SpatialPlaneGeometry extends SpatialGeometry {
+    id: string;
+    options: SpatialPlaneGeometryOptions;
+    static type: SpatialGeometryType;
+    constructor(id: string, options: SpatialPlaneGeometryOptions);
+}
+
+declare class SpatialConeGeometry extends SpatialGeometry {
+    id: string;
+    options: SpatialConeGeometryOptions;
+    static type: SpatialGeometryType;
+    constructor(id: string, options: SpatialConeGeometryOptions);
+}
+
+declare class SpatialModelAsset extends SpatialObject {
+    id: string;
+    options: ModelAssetOptions;
+    constructor(id: string, options: ModelAssetOptions);
+}
+
+declare function initScene(name: string, callback: (pre: SpatialSceneCreationOptions$1) => SpatialSceneCreationOptions$1, options?: {
+    type: SpatialSceneType$1;
+}): void;
+
+type SpatialSceneCreationOptionsInternal = SpatialSceneCreationOptions$1 & {
+    type: SpatialSceneType$1;
+};
+declare enum SpatialSceneState {
+    idle = "idle",
+    pending = "pending",
+    willVisible = "willVisible",
+    visible = "visible",
+    fail = "fail"
 }
 
 /**
- * PBR material which can be set on a SpatialModelComponent
+ * Represents the spatial scene that contains all spatialized elements.
+ * This class follows the singleton pattern - only one instance exists per application.
+ * The scene manages the overall spatial environment properties and contains all spatial elements.
  */
-declare class SpatialPhysicallyBasedMaterialResource extends SpatialObject {
+declare class SpatialScene extends SpatialObject {
     /**
-     * Base color of the material containing rgba between 0 and 1
+     * Gets the singleton instance of the SpatialScene.
+     * Creates a new instance if one doesn't exist yet.
+     * @returns The singleton SpatialScene instance
      */
-    baseColor: {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-    };
+    static getInstance(): SpatialScene;
     /**
-     * PBR metalic value between 0 and 1
+     * Updates the properties of the spatial scene.
+     * This can include background settings, lighting, and other scene-wide properties.
+     * @param properties Partial set of properties to update
+     * @returns Promise resolving when the update is complete
      */
-    metallic: {
-        value: number;
-    };
+    updateSpatialProperties(properties: Partial<SpatialSceneProperties>): Promise<CommandResult>;
     /**
-     * PBR roughness value between 0 and 1
+     * Adds a spatialized element to the scene.
+     * This makes the element visible and interactive in the spatial environment.
+     * @param element The SpatializedElement to add to the scene
+     * @returns Promise resolving when the element is added
      */
-    roughness: {
-        value: number;
-    };
-    _modelComponentAttachedTo: {
-        [key: string]: SpatialModelComponent;
-    };
-    _addToComponent(c: SpatialModelComponent): void;
-    /**
-     * Syncs state of color, metallic, roupghness to the renderer
-     */
-    update(): Promise<void>;
-}
-
-/**
- * Used to position a model in 3D space, made up of a mesh and materials to be applied to the mesh
- */
-declare class SpatialModelComponent extends SpatialComponent {
-    private cachedMaterials;
+    addSpatializedElement(element: SpatializedElement): Promise<CommandResult>;
     /**
-     * Sets the mesh to be displayed by the component
-     * @param mesh mesh to set
+     * Updates the scene creation configuration.
+     * This allows changing scene parameters after initial creation.
+     * @param config The new scene creation configuration
+     * @returns Promise resolving when the update is complete
      */
-    setMesh(mesh: SpatialMeshResource): Promise<void>;
+    updateSceneCreationConfig(config: SpatialSceneCreationOptionsInternal): Promise<CommandResult>;
     /**
-     * Sets the materials that should be applied to the mesh
-     * @param materials array of materials to set
+     * Gets the current state of the spatial scene.
+     * This includes information about active elements and scene configuration.
+     * @returns Promise resolving to the current SpatialSceneState
      */
-    setMaterials(materials: Array<SpatialPhysicallyBasedMaterialResource>): Promise<void>;
-    /** @hidden */
-    _syncMaterials(): Promise<void>;
+    getState(): Promise<SpatialSceneState>;
 }
 
 /**
- * Represenets a volume that can be added to the webpage
- * Child entities will be added within this volume's space
- * Defaults to having 1x1x1 meter dimensions
- * Resolution defaults to 100x100 pixels
- * Only will be displayed on entities in "ROOT" or "DOM" space
- * If the resolution of the spatial view is not a square, the volume will be larger based on the ratio with the shortest side being 1 meter.
- * (eg. 200x100 = 2m x 1m x 1m volume)
+ * Represents a 2D HTML element that has been spatialized in 3D space.
+ * This class handles the integration between 2D web content and the 3D spatial environment,
+ * allowing HTML elements to be positioned and interacted with in spatial applications.
  */
-declare class SpatialViewComponent extends SpatialComponent {
+declare class Spatialized2DElement extends SpatializedElement {
+    readonly windowProxy: WindowProxy;
     /**
-     * Sets the resolution of the spatial view in dom pixels
+     * Creates a new spatialized 2D element.
+     * @param id Unique identifier for this element
+     * @param windowProxy Reference to the window object containing the 2D content
      */
-    setResolution(width: number, height: number): Promise<void>;
+    constructor(id: string, windowProxy: WindowProxy);
     /**
-     * Sets if content of the spatialView should be within a portal
-     * If true, volume will be behind the page, if false, it will be in front of the page
+     * Updates the properties of this 2D element.
+     * This can include size, position, background, and other visual properties.
+     * @param properties Partial set of properties to update
+     * @returns Promise resolving when the update is complete
      */
-    setIsPortal(isPortal: Boolean): Promise<void>;
+    updateProperties(properties: Partial<Spatialized2DElementProperties>): Promise<CommandResult>;
+    /**
+     * Adds a child spatialized element to this 2D element.
+     * This allows for creating hierarchical structures of spatial elements.
+     * @param element The child element to add
+     * @returns Promise resolving when the element is added
+     */
+    addSpatializedElement(element: SpatializedElement): Promise<CommandResult>;
 }
 
 /**
- * Translate event, matching similar behavior to https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/drag_event
+ * Represents a static 3D model element in the spatial environment.
+ * This class handles loading and displaying pre-built 3D models from URLs,
+ * and provides events for load success and failure.
  */
-type SpatialModelDragEvent = {
-    eventType: 'dragstart' | 'dragend' | 'drag';
-    translation3D: Vec3;
-    startLocation3D: Vec3;
-};
-/**
- * Used to position a model3d in 3D space
- */
-declare class SpatialModel3DComponent extends EventSpatialComponent {
-    protected onRecvEvent(data: any): void;
-    /**
-     * Sets the resolution of the spatial view in dom pixels
-     */
-    setResolution(width: number, height: number): Promise<void>;
-    setRotationAnchor(rotationAnchor: Vec3): Promise<void>;
-    /**
-     * Sets the opacity of the model
-     * @param opacity
-     */
-    setOpacity(opacity: number): Promise<void>;
+declare class SpatializedStatic3DElement extends SpatializedElement {
     /**
-     * Sets how the model fill the rect
-     * @param contentMode
+     * Promise resolver for the ready state.
+     * Used to resolve the ready promise when the model is loaded.
      */
-    setContentMode(contentMode: 'fill' | 'fit'): Promise<void>;
+    private _readyResolve?;
     /**
-     * Constrains this model dimensions to the specified aspect ratio.
-     * with a value of 0, the model will use the original aspect ratio.
-     *
-     * @param aspectRatio number
+     * Caches the last model URL to detect changes.
+     * Used to reset the ready promise when the model URL changes.
      */
-    setAspectRatio(aspectRatio: number): Promise<void>;
+    private modelURL;
     /**
-     * Defaults to false. If set to true, scrolling the parent page will also scroll this window with it like other dom elements
-     * @param scrollWithParent value to set
+     * Creates a new promise for tracking the ready state of the model.
+     * @returns Promise that resolves when the model is loaded (true) or fails to load (false)
      */
-    setScrollWithParent(scrollWithParent: boolean): Promise<void>;
+    private createReadyPromise;
     /**
-     * Sets whether the model appear in original size or fit the rect
-     * @param resizable
+     * Promise that resolves when the model is loaded.
+     * Resolves to true on successful load, false on failure.
      */
-    setResizable(resizable: boolean): Promise<void>;
+    ready: Promise<boolean>;
     /**
-     * Callback fired when model load success
+     * Updates the properties of this static 3D element.
+     * Handles special case for modelURL changes by resetting the ready promise.
+     * @param properties Partial set of properties to update
+     * @returns Promise resolving when the update is complete
      */
-    onSuccess?: () => void;
+    updateProperties(properties: Partial<SpatializedStatic3DElementProperties>): Promise<CommandResult>;
     /**
-     * Callback fired when model load failure
-     * @param errorReason
+     * Processes events received from the WebSpatial environment.
+     * Handles model loading events in addition to base spatial events.
+     * @param data The event data received from the WebSpatial system
      */
-    onFailure?: (errorReason: string) => void;
+    onReceiveEvent(data: {
+        type: SpatialWebMsgType;
+    }): void;
     /**
-     * Callback fired when model was dragged at the beginning
-     * @param dragEvent
+     * Callback function for successful model loading.
      */
-    private _onDragStart?;
-    set onDragStart(callback: ((dragEvent: SpatialModelDragEvent) => void) | undefined);
+    private _onLoadCallback?;
     /**
-     * Callback fired when model was dragged
-     * @param dragEvent
+     * Sets the callback function for successful model loading.
+     * @param callback Function to call when the model is loaded successfully
      */
-    private _onDrag?;
-    set onDrag(callback: ((dragEvent: SpatialModelDragEvent) => void) | undefined);
+    set onLoadCallback(callback: undefined | (() => void));
     /**
-     * Callback fired when model was dragged at the ending
-     * @param dragEvent
+     * Callback function for model loading failure.
      */
-    private _onDragEnd?;
-    set onDragEnd(callback: ((dragEvent: SpatialModelDragEvent) => void) | undefined);
-    private get enableDragEvent();
+    private _onLoadFailureCallback?;
     /**
-     * Callback fired when model was tapped
+     * Sets the callback function for model loading failure.
+     * @param callback Function to call when the model fails to load
      */
-    private _onTap?;
-    set onTap(callback: (() => void) | undefined);
-    /** Callback fired when model was double tapped */
-    private _onDoubleTap?;
-    set onDoubleTap(callback: (() => void) | undefined);
-    /** Callback fired when model was long pressed */
-    private _onLongPress?;
-    set onLongPress(callback: (() => void) | undefined);
+    set onLoadFailureCallback(callback: undefined | (() => void));
+    updateModelTransform(transform: DOMMatrix): void;
 }
 
-type CreateResourceOptions = {
-    windowContainer?: SpatialWindowContainer | null;
-    windowComponent?: SpatialWindowComponent | null;
-};
 /**
- * Animation callback with timestamp
- */
-type animCallback = (time: DOMHighResTimeStamp) => Promise<any>;
-/**
- * Session use to establish a connection to the spatial renderer of the system. All resources must be created by the session
+ * Session used to establish a connection to the spatial renderer of the system.
+ * All spatial resources must be created through this session object.
+ * This class serves as the main factory for creating spatial elements and geometries.
  */
 declare class SpatialSession {
-    /** @hidden */
-    _engineUpdateListeners: animCallback[];
-    /** @hidden */
-    _frameLoopStarted: boolean;
     /**
-     * Add event listener callback to be called each frame
-     * @param callback callback to be called each update
+     * Gets the singleton instance of the spatial scene.
+     * The spatial scene is the root container for all spatial elements.
+     * @returns The SpatialScene singleton instance
      */
-    addOnEngineUpdateEventListener(callback: animCallback): void;
+    getSpatialScene(): SpatialScene;
     /**
-     * Creates a Entity
-     * @returns Entity
+     * Creates a new 2D element that can be spatialized in the 3D environment.
+     * 2D elements represent HTML content that can be positioned in 3D space.
+     * @returns Promise resolving to a new Spatialized2DElement instance
      */
-    createEntity(options?: CreateResourceOptions): Promise<SpatialEntity>;
+    createSpatialized2DElement(): Promise<Spatialized2DElement>;
     /**
-     * Creates a WindowComponent
-     * [TODO] should creation of components be moved to entity? and these made private?
-     * @returns WindowComponent
+     * Creates a new static 3D element with an optional model URL.
+     * Static 3D elements represent pre-built 3D models that can be loaded from a URL.
+     * @param modelURL Optional URL to the 3D model to load
+     * @returns Promise resolving to a new SpatializedStatic3DElement instance
      */
-    createWindowComponent(options?: CreateResourceOptions): Promise<SpatialWindowComponent>;
+    createSpatializedStatic3DElement(modelURL?: string): Promise<SpatializedStatic3DElement>;
     /**
-     * Creates a ViewComponent used to display 3D content within the entity
-     * @returns SpatialViewComponent
+     * Initializes the spatial scene with custom configuration.
+     * This is a reference to the initScene function from scene-polyfill.
      */
-    createViewComponent(options?: CreateResourceOptions): Promise<SpatialViewComponent>;
+    initScene: typeof initScene;
     /**
-     * Creates a ModelComponent used to display geometry + material of a 3D model
-     * @returns ModelComponent
+     * Creates a new dynamic 3D element that can be manipulated at runtime.
+     * Dynamic 3D elements allow for programmatic creation and modification of 3D content.
+     * @returns Promise resolving to a new SpatializedDynamic3DElement instance
      */
-    createModelComponent(options?: {
-        url: string;
-    } & CreateResourceOptions): Promise<SpatialModelComponent>;
+    createSpatializedDynamic3DElement(): Promise<SpatializedDynamic3DElement>;
     /**
-     * Creates a Model3DComponent
-     * @returns Model3DComponent
+     * Creates a new spatial entity with an optional name.
+     * Entities are the basic building blocks for creating custom 3D content.
+     * @param name Optional name for the entity
+     * @returns Promise resolving to a new SpatialEntity instance
      */
-    createModel3DComponent(options?: {
-        url: string;
-    } & CreateResourceOptions): Promise<SpatialModel3DComponent>;
+    createEntity(userData?: SpatialEntityUserData): Promise<SpatialEntity>;
     /**
-     * Creates a InputComponent
-     * [Experimental] Creates a InputComponent used to handle click and drag events of the entity containing a model
-     * @returns InputComponent
+     * Creates a box geometry with optional configuration.
+     * @param options Configuration options for the box geometry
+     * @returns Promise resolving to a new SpatialBoxGeometry instance
      */
-    createInputComponent(options?: CreateResourceOptions): Promise<SpatialInputComponent>;
+    createBoxGeometry(options?: SpatialBoxGeometryOptions): Promise<SpatialBoxGeometry>;
     /**
-     * Creates a MeshResource containing geometry data
-     * @returns MeshResource
+     * Creates a plane geometry with optional configuration.
+     * @param options Configuration options for the plane geometry
+     * @returns Promise resolving to a new SpatialPlaneGeometry instance
      */
-    createMeshResource(options?: {
-        shape?: string;
-    } & CreateResourceOptions): Promise<SpatialMeshResource>;
+    createPlaneGeometry(options?: SpatialPlaneGeometryOptions): Promise<SpatialPlaneGeometry>;
     /**
-     * Creates a PhysicallyBasedMaterial containing PBR material data
-     * @returns PhysicallyBasedMaterial
+     * Creates a sphere geometry with optional configuration.
+     * @param options Configuration options for the sphere geometry
+     * @returns Promise resolving to a new SpatialSphereGeometry instance
      */
-    createPhysicallyBasedMaterialResource(options?: {} & CreateResourceOptions): Promise<SpatialPhysicallyBasedMaterialResource>;
+    createSphereGeometry(options?: SpatialSphereGeometryOptions): Promise<SpatialSphereGeometry>;
     /**
-     * Creates a WindowContainer
-     * @returns SpatialWindowContainer
-     * */
-    createWindowContainer(options?: {
-        style: WindowStyle;
-    } & CreateResourceOptions): Promise<SpatialWindowContainer>;
-    /**
-     * Creates a Scene to display content within an anchored area managed by the OS
-     * @hidden
-     * @param {WindowStyle} [style='Plain'] - The style of the Scene container to be created with. Defaults to 'Plain'.
-     * @param {Object} [cfg={}] - Configuration object for the Scene.
-     * @returns Boolean
-     */
-    _createScene(style: WindowStyle | undefined, cfg: {
-        sceneData: sceneDataShape;
-    }): Promise<boolean>;
-    /**
-     * Retrieves the window for this page
-     * @returns the window component corresponding to the js running on this page
-     * [TODO] discuss implications of this not being async
+     * Creates a cone geometry with the specified configuration.
+     * @param options Configuration options for the cone geometry
+     * @returns Promise resolving to a new SpatialConeGeometry instance
      */
-    getCurrentWindowComponent(): SpatialWindowComponent;
+    createConeGeometry(options: SpatialConeGeometryOptions): Promise<SpatialConeGeometry>;
     /**
-     * Retrieves the parent window for this page or null if this is the root page
-     * @returns the window component or null
+     * Creates a cylinder geometry with the specified configuration.
+     * @param options Configuration options for the cylinder geometry
+     * @returns Promise resolving to a new SpatialCylinderGeometry instance
      */
-    getParentWindowComponent(): Promise<SpatialWindowComponent | null>;
+    createCylinderGeometry(options: SpatialCylinderGeometryOptions): Promise<SpatialCylinderGeometry>;
     /**
-     * Logs a message to the native apps console
-     * @param msg mesage to log
+     * Creates a model component with the specified configuration.
+     * Model components are used to add 3D model rendering capabilities to entities.
+     * @param options Configuration options for the model component
+     * @returns Promise resolving to a new ModelComponent instance
      */
-    log(...msg: any[]): Promise<void>;
+    createModelComponent(options: ModelComponentOptions): Promise<ModelComponent>;
     /**
-     * @hidden
-     * Debugging only, used to ping the native renderer
+     * Creates an unlit material with the specified configuration.
+     * Unlit materials don't respond to lighting in the scene.
+     * @param options Configuration options for the unlit material
+     * @returns Promise resolving to a new SpatialUnlitMaterial instance
      */
-    _ping(msg: string): Promise<unknown>;
+    createUnlitMaterial(options: SpatialUnlitMaterialOptions): Promise<SpatialUnlitMaterial>;
     /**
-     * @hidden
-     * Debugging to get internal state from native code
-     * @returns stats from native code. Objects tracks number of native objects that were created but not yet explicitly destroyed. RefObjects tracks bjects that still have references. After an object is destroyed, we should be cleaning up all of the native references. Expect objects.count == refObjects.count , if not, there is likely a leak.
+     * Creates a model asset with the specified configuration.
+     * Model assets represent 3D model resources that can be used by entities.
+     * @param options Configuration options for the model asset
+     * @returns Promise resolving to a new SpatialModelAsset instance
      */
-    _getStats(): Promise<{
-        backend: string;
-        objects: {
-            count: number;
-        };
-        refObjects: {
-            count: number;
-        };
-    }>;
+    createModelAsset(options: ModelAssetOptions): Promise<SpatialModelAsset>;
     /**
-     * @hidden
+     * Creates a spatial model entity with the specified configuration.
+     * This is a convenience method for creating an entity with a model component.
+     * @param options Configuration options for the spatial model entity
+     * @returns Promise resolving to a new SpatialModelEntity instance
      */
-    _inspect(spatialObjectId?: string): Promise<any>;
-    /**
-     * @hidden
-     */
-    _inspectRootWindowContainer(): Promise<any>;
-    /** Opens the immersive space */
-    openImmersiveSpace(): Promise<void>;
-    /** Closes the immersive space */
-    dismissImmersiveSpace(): Promise<void>;
-    private static _immersiveWindowContainer;
-    /**
-     * Retreives the window container corresponding to the Immersive space
-     * @returns the immersive window container
-     */
-    getImmersiveWindowContainer(): Promise<SpatialWindowContainer>;
-    private static _currentWindowContainer;
-    /**
-     * Gets the current window container for the window
-     * [TODO] discuss what happens if it doesnt yet have a window container
-     * @returns the current window container for the window
-     */
-    getCurrentWindowContainer(): SpatialWindowContainer;
-    /**
-     * Start a transaction that queues up commands to submit them all at once to reduce ipc overhead
-     * @param fn function to be run, within this function, promises will not resolve
-     * @returns promise for the entire transaction completion
-     */
-    transaction(fn: Function): Promise<unknown>;
-    /**
-     * Creates a window context object that is compatable with SpatialWindowComponent's setFromWindow API
-     * @returns window context
-     */
-    createWindowContext(): Promise<Window | null>;
-    /** @hidden */
-    _getEntity(id: string): Promise<SpatialEntity>;
-    /** @hidden */
-    setLoading(method: LoadingMethodKind, style?: string): Promise<unknown>;
+    createSpatialModelEntity(options: SpatialModelEntityCreationOptions, userData?: SpatialEntityUserData): Promise<SpatialModelEntity>;
 }
 
 /**
- * Base object designed to be placed on navigator.spatial to mirror navigator.xr for webxr
+ * Base object designed to be placed on navigator.spatial to mirror navigator.xr for webxr.
+ * This is the main entry point for the WebSpatial SDK, providing access to spatial capabilities.
  */
 declare class Spatial {
     /**
-     * Requests a session object from the browser
-     * @returns The session or null if not availible in the current browser
+     * Requests a spatial session object from the browser.
+     * This is the primary method to initialize spatial functionality.
+     * @returns The SpatialSession instance or null if not available in the current browser
      * [TODO] discuss implications of this not being async
      */
     requestSession(): SpatialSession | null;
     /**
-     * @returns true if web spatial is supported by this webpage
+     * Checks if the current page is running in a spatial web environment.
+     * This method detects if the application is running in a WebSpatial-compatible browser.
+     * @returns True if running in a spatial web environment, false otherwise
+     */
+    runInSpatialWeb(): boolean;
+    /** @deprecated
+     * Checks if WebSpatial is supported in the current environment.
+     * Verifies compatibility between native and client versions.
+     * @returns True if web spatial is supported by this webpage
      */
     isSupported(): boolean;
-    /**
-     * Gets the native version, format is "x.x.x"
-     * @returns native version string
+    /** @deprecated
+     * Gets the native WebSpatial version from the browser environment.
+     * The version format follows semantic versioning (x.x.x).
+     * @returns Native version string in format "x.x.x"
      */
     getNativeVersion(): any;
-    /**
-     * Gets the client version, format is "x.x.x"
-     * @returns client version string
+    /** @deprecated
+     * Gets the client SDK version.
+     * The version format follows semantic versioning (x.x.x).
+     * @returns Client SDK version string in format "x.x.x"
      */
     getClientVersion(): string;
 }
 
-/**
- * Helper class used to quickly add spatial content to standard web pages
- * [Experimental] expect APIs to potentially change in future versions
- */
-declare class SpatialHelper {
-    session: SpatialSession;
-    private static _instance;
-    static get instance(): SpatialHelper | null;
-    constructor(session: SpatialSession);
-    shape: {
-        createShapeEntity: (shape?: string) => Promise<SpatialEntity>;
-        createModelEntity: (url: string) => Promise<SpatialEntity>;
-        wrapInBoundingBoxEntity: (entityToWrap: SpatialEntity) => Promise<SpatialEntity>;
-    };
-    navigation: {
-        openPanel: (url: string, options?: {
-            resolution: {
-                width: number;
-                height: number;
-            };
-        }) => Promise<{
-            windowContainer: SpatialWindowContainer;
-        }>;
-        openVolume: (url: string, options?: {
-            resolution: {
-                width: number;
-                height: number;
-            };
-        }) => Promise<void>;
-    };
-    dom: {
-        attachSpatialView: (divOnPage: HTMLElement) => Promise<{
-            entity: SpatialEntity;
-        }>;
-    };
-    setBackgroundStyle: (style: StyleParam, backgroundColor?: string) => Promise<void>;
+declare global {
+  declare const __WEBSPATIAL_CORE_SDK_VERSION__: string
+
+  interface Window {
+    xrCurrentSceneType: SpatialSceneType
+    xrCurrentSceneDefaults: (
+      defaultConfig: SpatialSceneCreationOptions,
+    ) => Promise<SpatialSceneCreationOptions>
+
+    // Location for webspatial custom functions
+    __WebSpatialData: {
+      androidNativeMessage: Function
+      getNativeVersion: Function
+    }
+
+    // Location for webspatial internal callbacks (eg. completion events)
+    __SpatialWebEvent: Function
+
+    // Used to access webkit specific api
+    webkit: any
+    webspatialBridge: any
+
+    // Will be removed in favor of __WebSpatialData
+    WebSpatailNativeVersion: string
+
+    __webspatialsdk__?: {
+      XR_ENV?: string
+      'natvie-version'?: string
+      'react-sdk-version'?: string
+      'core-sdk-version'?: string
+    }
+
+    innerDepth: number
+    outerDepth: number
+  }
+
+  interface HTMLElement {
+    offsetBack: number
+    clientDepth: number
+    getBoundingClientCube: () => CubeInfo | undefined
+  }
 }
 
-export { type BackgroundMaterialType, type CornerRadius, type LoadingMethodKind, Spatial, SpatialComponent, SpatialEntity, SpatialHelper, SpatialInputComponent, SpatialMeshResource, SpatialModel3DComponent, SpatialModelComponent, type SpatialModelDragEvent, SpatialPhysicallyBasedMaterialResource, SpatialSession, SpatialTransform, SpatialViewComponent, SpatialWindowComponent, SpatialWindowContainer, type StyleParam, Vec3, Vec4, type WindowContainerOptions, type WindowStyle, type sceneDataJSBShape, type sceneDataShape };
+declare const isSSREnv: () => boolean;
+
+export { type BackgroundMaterialType, type BaseplateVisibilityType, BaseplateVisibilityValues, type CornerRadius, CubeInfo$1 as CubeInfo, type ModelAssetOptions, ModelComponent, type ModelComponentOptions, type Point3D, type Size, type Size3D, Spatial, SpatialBoxGeometry, type SpatialBoxGeometryOptions, SpatialComponent, SpatialConeGeometry, type SpatialConeGeometryOptions, SpatialCylinderGeometry, type SpatialCylinderGeometryOptions, type SpatialDragEndEvent, type SpatialDragEvent, type SpatialDragEventDetail, SpatialEntity, type SpatialEntityEventType, type SpatialEntityOrReality, type SpatialEntityProperties, type SpatialEntityUserData, SpatialGeometry, type SpatialGeometryOptions, type SpatialGeometryType, type SpatialMagnifyEndEvent, type SpatialMagnifyEvent, type SpatialMagnifyEventDetail, SpatialMaterial, type SpatialMaterialType, SpatialModelAsset, type SpatialModelDragEvent, SpatialModelEntity, type SpatialModelEntityCreationOptions, SpatialObject, SpatialPlaneGeometry, type SpatialPlaneGeometryOptions, type SpatialRotateEndEvent, type SpatialRotateEvent, type SpatialRotateEventDetail, SpatialScene, type SpatialSceneCreationOptions$1 as SpatialSceneCreationOptions, type SpatialSceneProperties, SpatialSceneState$1 as SpatialSceneState, type SpatialSceneType$1 as SpatialSceneType, SpatialSceneValues, SpatialSession, SpatialSphereGeometry, type SpatialSphereGeometryOptions, type SpatialTapEvent, type SpatialTapEventDetail, SpatialUnlitMaterial, type SpatialUnlitMaterialOptions, Spatialized2DElement, type Spatialized2DElementProperties, SpatializedDynamic3DElement, SpatializedElement, type SpatializedElementProperties, SpatializedElementType, SpatializedStatic3DElement, type SpatializedStatic3DElementProperties, type Vec3, type WorldAlignmentType, WorldAlignmentValues, type WorldScalingType, WorldScalingValues, isSSREnv, isValidBaseplateVisibilityType, isValidSceneUnit, isValidSpatialSceneType, isValidWorldAlignmentType, isValidWorldScalingType };