@webspatial/react-sdk 0.0.0-beta-a19231bc7abce8581b3209af150c2726eb00c4f7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Spatial Web
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+<div align="left">
+  <img src="../../assets/logo.png" alt="WebSpatial Logo" width="400"/>
+</div>
+<br/>
+
+# React SDK for WebSpatial
+
+The React SDK from the WebSpatial SDK makes the WebSpatial API immediately available inside React.
+
+## Documentation
+
+- [Introduction](https://webspatial.dev/docs/introduction)
+- [Quick Example](https://webspatial.dev/docs/quick-example)
+- [Core Concepts](https://webspatial.dev/docs/core-concepts)
+- [Development Guide](https://webspatial.dev/docs/development-guide)
+
+## SpatialDiv `onSpatialContentReady` runtime note
+
+When using nested `SpatialDiv` (`enable-xr`) with `onSpatialContentReady`, callback ordering differs by runtime:
+
+- In WebSpatial runtime, parent `SpatialDiv` callback runs before child callback on the same ready edge.
+- In non-WebSpatial fallback (plain web DOM), callback ordering between parent and child is not a guaranteed contract and should be treated as unspecified.
+
+Recommended practice: initialize imperative renderers from each container's own `ctx.host` and avoid coupling setup logic to parent/child callback sequence in fallback web mode.

package/dist/default/index.d.ts

@@ -0,0 +1,462 @@
+import * as _webspatial_core_sdk from '@webspatial/core-sdk';
+import { supports, SpatialSceneCreationOptions, SpatialSceneType, Vec3, SpatialTapEvent as SpatialTapEvent$1, SpatialDragStartEvent as SpatialDragStartEvent$1, SpatialDragEvent as SpatialDragEvent$1, SpatialDragEndEvent as SpatialDragEndEvent$1, SpatialRotateEvent as SpatialRotateEvent$1, SpatialRotateEndEvent as SpatialRotateEndEvent$1, SpatialMagnifyEvent as SpatialMagnifyEvent$1, SpatialMagnifyEndEvent as SpatialMagnifyEndEvent$1, SpatializedElement, SpatialObject, SpatialSession, SpatializedDynamic3DElement, SpatialEntity, Quaternion, SpatialBoxGeometryOptions, SpatialUnlitMaterialOptions, SpatialSphereGeometryOptions, SpatialConeGeometryOptions, SpatialCylinderGeometryOptions, SpatialPlaneGeometryOptions, PhysicalMetrics } from '@webspatial/core-sdk';
+export { CapabilityKey, Point3D, Vec3, WebSpatialRuntimeError } from '@webspatial/core-sdk';
+import * as React$1 from 'react';
+import React__default, { ElementType, ForwardedRef, createElement as createElement$1 } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * Runtime capability checks (`supports('Model')`, `supports('WindowScene', ['defaultSize'])`, ...).
+ * Spec: `openspec/specs/runtime-capabilities/spec.md`.
+ */
+declare const WebSpatialRuntime: {
+    readonly supports: typeof supports;
+};
+
+declare function enableDebugTool(): void;
+
+/**
+ * Resolve asset URLs for the native bridge: relative paths become absolute against the
+ * current document (typical dev server is `http://localhost/...`).
+ *
+ * With no `window` (SSR), returns `url` unchanged — pass absolute `http(s)` URLs if needed.
+ */
+declare function getAbsoluteUrl(url: string): string;
+
+declare function initScene(name: string, callback: (pre: SpatialSceneCreationOptions) => SpatialSceneCreationOptions, options?: {
+    type: SpatialSceneType;
+}): void | undefined;
+
+declare const SpatialID = "data-spatial-id";
+
+/** Connected content root for imperative mounting (portal root or web fallback host). */
+type SpatialContentReadyContext = {
+    host: HTMLElement;
+};
+type SpatialContentReadyCallback = (ctx: SpatialContentReadyContext) => void | (() => void);
+/** Options for spatial pointer/gesture behavior (not DOM attributes). */
+type SpatialEventOptions = {
+    /**
+     * Direction vector for rotate gesture constraint. `[0, 0, 0]` or omit = unconstrained.
+     */
+    constrainedToAxis?: Vec3 | readonly [number, number, number];
+};
+type SpatialEventProps<T extends SpatializedElementRef> = {
+    onSpatialTap?: (event: SpatialTapEvent<T>) => void;
+    onSpatialDragStart?: (event: SpatialDragStartEvent<T>) => void;
+    onSpatialDrag?: (event: SpatialDragEvent<T>) => void;
+    onSpatialDragEnd?: (event: SpatialDragEndEvent<T>) => void;
+    onSpatialRotate?: (event: SpatialRotateEvent<T>) => void;
+    onSpatialRotateEnd?: (event: SpatialRotateEndEvent<T>) => void;
+    onSpatialMagnify?: (event: SpatialMagnifyEvent<T>) => void;
+    onSpatialMagnifyEnd?: (event: SpatialMagnifyEndEvent<T>) => void;
+};
+interface StandardSpatializedContainerProps extends React__default.ComponentPropsWithoutRef<'div'> {
+    component: ElementType;
+    inStandardSpatializedContainer?: boolean;
+    [SpatialID]: string;
+}
+type PortalSpatializedContainerProps<T extends SpatializedElementRef> = SpatialEventProps<T> & React__default.ComponentPropsWithoutRef<'div'> & {
+    component: ElementType;
+    spatializedContent: ElementType;
+    createSpatializedElement: () => Promise<SpatializedElement>;
+    getExtraSpatializedElementProperties?: (computedStyle: CSSStyleDeclaration) => Record<string, any>;
+    spatialEventOptions?: SpatialEventOptions;
+    [SpatialID]: string;
+};
+type SpatializedContainerProps<T extends SpatializedElementRef> = Omit<StandardSpatializedContainerProps & PortalSpatializedContainerProps<T>, typeof SpatialID | 'onLoad' | 'onError'> & {
+    extraRefProps?: (domProxy: T) => Record<string, unknown>;
+    /**
+     * SpatialDiv only — fired when `ctx.host` is connected (portal root or web fallback host).
+     * Not part of `Model` / `Reality` public APIs.
+     */
+    onSpatialContentReady?: SpatialContentReadyCallback;
+};
+type Spatialized2DElementContainerProps<P extends ElementType> = SpatialEventProps<SpatializedElementRef> & React__default.ComponentPropsWithRef<'div'> & {
+    component: P;
+    spatialEventOptions?: SpatialEventOptions;
+    onSpatialContentReady?: SpatialContentReadyCallback;
+};
+type SpatializedStatic3DContainerProps = SpatialEventProps<SpatializedStatic3DElementRef> & Omit<React__default.ComponentPropsWithoutRef<'div'>, 'onLoad' | 'onError'> & {
+    src?: string;
+    poster?: string;
+    autoPlay?: boolean;
+    loop?: boolean;
+    children?: React__default.ReactNode;
+    onLoad?: (event: ModelLoadEvent) => void;
+    onError?: (event: ModelLoadEvent) => void;
+    spatialEventOptions?: SpatialEventOptions;
+};
+type SpatializedElementRef<T extends HTMLElement = HTMLElement> = T;
+type SpatializedDivElementRef = SpatializedElementRef<HTMLDivElement>;
+type SpatializedStatic3DElementRef = SpatializedDivElementRef & {
+    currentSrc: string;
+    ready: Promise<ModelLoadEvent>;
+    entityTransform: DOMMatrixReadOnly;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    readonly paused: boolean;
+    readonly duration: number;
+    playbackRate: number;
+    currentTime: number;
+};
+type CurrentTarget<T extends SpatializedElementRef> = {
+    currentTarget: T;
+};
+type SpatialTapEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialTapEvent$1 & CurrentTarget<T> & {
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly offsetZ: number;
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly clientZ: number;
+};
+type SpatialDragStartEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialDragStartEvent$1 & CurrentTarget<T> & {
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly offsetZ: number;
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly clientZ: number;
+};
+type SpatialDragEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialDragEvent$1 & CurrentTarget<T> & {
+    readonly translationX: number;
+    readonly translationY: number;
+    readonly translationZ: number;
+};
+type SpatialDragEndEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialDragEndEvent$1 & CurrentTarget<T>;
+type SpatialRotateEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialRotateEvent$1 & CurrentTarget<T> & {
+    readonly quaternion: _webspatial_core_sdk.Quaternion;
+};
+type SpatialRotateEndEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialRotateEndEvent$1 & CurrentTarget<T>;
+type SpatialMagnifyEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialMagnifyEvent$1 & CurrentTarget<T> & {
+    readonly magnification: number;
+};
+type SpatialMagnifyEndEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialMagnifyEndEvent$1 & CurrentTarget<T>;
+type ModelSpatialTapEvent = SpatialTapEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialDragStartEvent = SpatialDragStartEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialDragEvent = SpatialDragEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialDragEndEvent = SpatialDragEndEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialRotateEvent = SpatialRotateEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialRotateEndEvent = SpatialRotateEndEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialMagnifyEvent = SpatialMagnifyEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialMagnifyEndEvent = SpatialMagnifyEndEvent<SpatializedStatic3DElementRef>;
+type ModelLoadEvent = CustomEvent & {
+    target: SpatializedStatic3DElementRef;
+};
+
+declare const SpatializedContainer: <T extends SpatializedElementRef>(props: SpatializedContainerProps<T> & {
+    ref?: ForwardedRef<SpatializedElementRef<T>>;
+}) => React.ReactElement | null;
+
+declare const Spatialized2DElementContainer: <P extends ElementType>(props: Spatialized2DElementContainerProps<P> & {
+    ref: ForwardedRef<SpatializedElementRef>;
+}) => React__default.ReactElement | null;
+
+declare const SpatializedStatic3DElementContainer: React$1.ForwardRefExoticComponent<{
+    onSpatialTap?: ((event: SpatialTapEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDragStart?: ((event: SpatialDragStartEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDrag?: ((event: SpatialDragEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDragEnd?: ((event: SpatialDragEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialRotate?: ((event: SpatialRotateEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialRotateEnd?: ((event: SpatialRotateEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialMagnify?: ((event: SpatialMagnifyEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialMagnifyEnd?: ((event: SpatialMagnifyEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+} & Omit<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onLoad" | "onError"> & {
+    src?: string;
+    poster?: string;
+    autoPlay?: boolean;
+    loop?: boolean;
+    children?: React.ReactNode;
+    onLoad?: (event: ModelLoadEvent) => void;
+    onError?: (event: ModelLoadEvent) => void;
+    spatialEventOptions?: SpatialEventOptions;
+} & React$1.RefAttributes<SpatializedStatic3DElementRef>>;
+
+declare function withSpatialized2DElementContainer<P extends ElementType>(Component: P): P | React$1.ForwardRefExoticComponent<Omit<Spatialized2DElementContainerProps<P>, "ref"> & React$1.RefAttributes<HTMLElement>>;
+
+declare function initPolyfill(): void;
+
+declare function withSpatialMonitor(El: React__default.ElementType): any;
+
+type SpatialMonitorProps = {
+    El?: ElementType;
+};
+declare const SpatialMonitor: React$1.ForwardRefExoticComponent<SpatialMonitorProps & React$1.RefAttributes<HTMLElement>>;
+
+/**
+ * Tracks spatial resources (textures, materials, entities, …) by string id under one Reality.
+ *
+ * Native creation is async (`createTexture`, `createUnlitMaterial`, …). The map
+ * stores `Promise<SpatialObject>` so `add(id, pendingCreation)` can run after `get(id)` — sibling
+ * JSX order does not need to match registration order. Callers are responsible for using the
+ * correct id for each resource kind (same as with string ids today).
+ *
+ * Callers can `await get(id)` before `add(id, promise)` runs: `get` returns a promise that
+ * settles when something later calls `add` with the same id.
+ */
+declare class ResourceRegistry {
+    /** Every id maps to a promise — either the real resource from add(), or a placeholder until then. */
+    private resources;
+    /** If get() ran first, we stash resolve/reject so add() can complete the waiting promise. */
+    private deferreds;
+    add<T extends SpatialObject>(id: string, resource: Promise<T>): void;
+    get(id: string): Promise<SpatialObject>;
+    remove(id: string): void;
+    removeAndDestroy(id: string): void;
+    destroy(): void;
+}
+
+type ContainerEntry = {
+    instanceId: string;
+    container: HTMLElement;
+};
+type ContainersChangeCallback = (containers: ContainerEntry[]) => void;
+declare class AttachmentRegistry {
+    private containers;
+    private listeners;
+    addContainer(name: string, instanceId: string, container: HTMLElement): void;
+    removeContainer(name: string, instanceId: string): void;
+    getContainers(name: string): ContainerEntry[];
+    onContainersChange(name: string, cb: ContainersChangeCallback): () => void;
+    private notifyListeners;
+    destroy(): void;
+}
+
+type RealityContextValue = {
+    session: SpatialSession;
+    reality: SpatializedDynamic3DElement;
+    resourceRegistry: ResourceRegistry;
+    attachmentRegistry: AttachmentRegistry;
+} | null;
+
+interface EntityRefShape {
+    convertFromEntityToEntity: (fromEntityId: string, toEntityId: string, position: Vec3) => Promise<Vec3>;
+    convertFromEntityToReality: (entityId: string, position: Vec3) => Promise<Vec3>;
+    convertFromRealityToEntity: (entityId: string, position: Vec3) => Promise<Vec3>;
+    id: string | undefined;
+    name: string | undefined;
+    entity: SpatialEntity | null;
+}
+declare class EntityRef implements EntityRefShape {
+    private _entity;
+    private _ctx;
+    constructor(entity?: SpatialEntity | null, ctx?: RealityContextValue | null);
+    updateEntity(entity?: SpatialEntity | null): void;
+    updateCtx(ctx?: RealityContextValue | null): void;
+    destroy(): void;
+    get entity(): SpatialEntity | null;
+    get id(): string | undefined;
+    get name(): string | undefined;
+    convertFromEntityToEntity(fromEntityId: string, toEntityId: string, position: Vec3): Promise<Vec3>;
+    convertFromEntityToReality(entityId: string, position: Vec3): Promise<Vec3>;
+    convertFromRealityToEntity(entityId: string, position: Vec3): Promise<Vec3>;
+}
+
+type EntityProps = {
+    id?: string;
+    name?: string;
+    position?: Vec3;
+    rotation?: Vec3;
+    scale?: Vec3;
+    enableInput?: boolean;
+};
+type allTarget<T extends EntityRefShape> = {
+    target: T;
+    currentTarget: T;
+};
+type SpatialTapEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialTapEvent$1 & allTarget<T> & {
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly offsetZ: number;
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly clientZ: number;
+};
+type SpatialDragStartEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialDragStartEvent$1 & allTarget<T> & {
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly offsetZ: number;
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly clientZ: number;
+};
+type SpatialDragEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialDragEvent$1 & allTarget<T> & {
+    readonly translationX: number;
+    readonly translationY: number;
+    readonly translationZ: number;
+};
+type SpatialDragEndEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialDragEndEvent$1 & allTarget<T>;
+type SpatialRotateEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialRotateEvent$1 & allTarget<T> & {
+    readonly quaternion: Quaternion;
+};
+type SpatialRotateEndEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialRotateEndEvent$1 & allTarget<T>;
+type SpatialMagnifyEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialMagnifyEvent$1 & allTarget<T> & {
+    readonly magnification: number;
+};
+type SpatialMagnifyEndEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialMagnifyEndEvent$1 & allTarget<T>;
+type EntityEventHandler = {
+    onSpatialTap?: (event: SpatialTapEntityEvent) => void;
+    onSpatialDragStart?: (event: SpatialDragStartEntityEvent) => void;
+    onSpatialDrag?: (event: SpatialDragEntityEvent) => void;
+    onSpatialDragEnd?: (event: SpatialDragEndEntityEvent) => void;
+    spatialEventOptions?: SpatialEventOptions;
+    onSpatialRotate?: (event: SpatialRotateEntityEvent) => void;
+    onSpatialRotateEnd?: (event: SpatialRotateEndEntityEvent) => void;
+    onSpatialMagnify?: (event: SpatialMagnifyEntityEvent) => void;
+    onSpatialMagnifyEnd?: (event: SpatialMagnifyEndEntityEvent) => void;
+};
+declare const eventMap: {
+    readonly onSpatialTap: "spatialtap";
+    readonly onSpatialDragStart: "spatialdragstart";
+    readonly onSpatialDrag: "spatialdrag";
+    readonly onSpatialDragEnd: "spatialdragend";
+    readonly onSpatialRotate: "spatialrotate";
+    readonly onSpatialRotateEnd: "spatialrotateend";
+    readonly onSpatialMagnify: "spatialmagnify";
+    readonly onSpatialMagnifyEnd: "spatialmagnifyend";
+};
+
+declare const Entity: React__default.ForwardRefExoticComponent<EntityProps & {
+    children?: React__default.ReactNode;
+} & React__default.RefAttributes<EntityRefShape>>;
+
+declare const BoxEntity: React__default.ForwardRefExoticComponent<EntityProps & {
+    children?: React__default.ReactNode;
+    materials?: string[];
+} & SpatialBoxGeometryOptions & React__default.RefAttributes<EntityRefShape>>;
+
+type UnlitMaterialProps = {
+    children?: React__default.ReactNode;
+    id: string;
+} & SpatialUnlitMaterialOptions;
+declare const UnlitMaterial: React__default.FC<UnlitMaterialProps>;
+
+type TextureProps = {
+    children?: React__default.ReactNode;
+    id: string;
+    url: string;
+    onLoad?: () => void;
+    onError?: (error: unknown) => void;
+};
+declare const Texture: React__default.FC<TextureProps>;
+
+declare const SphereEntity: React__default.ForwardRefExoticComponent<EntityProps & {
+    children?: React__default.ReactNode;
+    materials?: string[];
+} & SpatialSphereGeometryOptions & React__default.RefAttributes<EntityRefShape>>;
+
+declare const ConeEntity: React__default.ForwardRefExoticComponent<EntityProps & {
+    children?: React__default.ReactNode;
+    materials?: string[];
+} & SpatialConeGeometryOptions & React__default.RefAttributes<EntityRefShape>>;
+
+declare const CylinderEntity: React__default.ForwardRefExoticComponent<EntityProps & {
+    children?: React__default.ReactNode;
+    materials?: string[];
+} & SpatialCylinderGeometryOptions & React__default.RefAttributes<EntityRefShape>>;
+
+declare const PlaneEntity: React__default.ForwardRefExoticComponent<EntityProps & {
+    children?: React__default.ReactNode;
+    materials?: string[];
+} & SpatialPlaneGeometryOptions & React__default.RefAttributes<EntityRefShape>>;
+
+type Props$1 = {
+    children?: React__default.ReactNode;
+};
+declare const SceneGraph: React__default.FC<Props$1>;
+
+type Props = {
+    children?: React__default.ReactNode;
+    id: string;
+    src: string;
+    onLoad?: () => void;
+    onError?: (error: unknown) => void;
+};
+declare const ModelAsset: React__default.FC<Props>;
+
+declare const ModelEntity: React__default.ForwardRefExoticComponent<EntityProps & {
+    model: string;
+    materials?: string[];
+} & EntityEventHandler & {
+    children?: React__default.ReactNode;
+} & React__default.RefAttributes<EntityRefShape>>;
+
+type RealityProps = Omit<React__default.ComponentPropsWithRef<'div'>, 'onSpatialContentReady'> & EntityEventHandler;
+declare const Reality: React__default.ForwardRefExoticComponent<Omit<RealityProps, "ref"> & React__default.RefAttributes<HTMLElement>>;
+
+type AttachmentAssetProps = {
+    name: string;
+    children?: React__default.ReactNode;
+};
+declare const AttachmentAsset: React__default.FC<AttachmentAssetProps>;
+
+type AttachmentEntityProps = {
+    attachment: string;
+    position?: [number, number, number];
+    size: {
+        width: number;
+        height: number;
+    };
+};
+declare const AttachmentEntity: React__default.FC<AttachmentEntityProps>;
+
+type MaterialProps = {
+    type: 'unlit';
+} & UnlitMaterialProps;
+declare const Material: React__default.FC<MaterialProps>;
+
+type ModelProps = SpatializedStatic3DContainerProps & {
+    'enable-xr'?: boolean;
+};
+type ModelRef = SpatializedStatic3DElementRef;
+declare const Model: React$1.ForwardRefExoticComponent<Omit<{
+    onSpatialTap?: ((event: SpatialTapEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDragStart?: ((event: SpatialDragStartEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDrag?: ((event: SpatialDragEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDragEnd?: ((event: SpatialDragEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialRotate?: ((event: SpatialRotateEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialRotateEnd?: ((event: SpatialRotateEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialMagnify?: ((event: SpatialMagnifyEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialMagnifyEnd?: ((event: SpatialMagnifyEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+} & Omit<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onLoad" | "onError"> & {
+    src?: string;
+    poster?: string;
+    autoPlay?: boolean;
+    loop?: boolean;
+    children?: React.ReactNode;
+    onLoad?: (event: ModelLoadEvent) => void;
+    onError?: (event: ModelLoadEvent) => void;
+    spatialEventOptions?: SpatialEventOptions;
+} & {
+    'enable-xr'?: boolean;
+} & React$1.RefAttributes<SpatializedStatic3DElementRef>, "ref"> & React$1.RefAttributes<any>>;
+
+declare const SSRProvider: ({ isSSR: initialIsSSR, children, }: {
+    isSSR?: boolean;
+    children: React__default.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+declare function useMetrics(): {
+    pointToPhysical: typeof PhysicalMetrics.pointToPhysical;
+    physicalToPoint: typeof PhysicalMetrics.physicalToPoint;
+};
+
+declare function createElement(...args: Parameters<typeof createElement$1>): React$1.DetailedReactHTMLElement<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+
+/**
+ * const e2e = await convertCoordinate(position, { from: elementOrEntity, to: elementOrEntity })
+const e2w = await convertCoordinate(position, { from: elementOrEntity, to: window })
+const w2e = await convertCoordinate(position, { from: window, to: elementOrEntity })
+ *
+ */
+
+type CoordinateConvertible = Window | SpatializedElementRef<any> | EntityRef | ModelRef;
+declare function convertCoordinate(position: Vec3, { from, to }: {
+    from: CoordinateConvertible;
+    to: CoordinateConvertible;
+}): Promise<Vec3>;
+
+declare const version: string;
+
+export { AttachmentAsset, AttachmentEntity, BoxEntity as Box, BoxEntity, ConeEntity as Cone, ConeEntity, CylinderEntity as Cylinder, CylinderEntity, Entity, type EntityEventHandler, type EntityProps, EntityRef, Material, type MaterialProps, Model, ModelAsset, ModelEntity, type ModelLoadEvent, type ModelProps, type ModelRef, type ModelSpatialDragEndEvent, type ModelSpatialDragEvent, type ModelSpatialDragStartEvent, type ModelSpatialMagnifyEndEvent, type ModelSpatialMagnifyEvent, type ModelSpatialRotateEndEvent, type ModelSpatialRotateEvent, type ModelSpatialTapEvent, PlaneEntity as Plane, PlaneEntity, Reality, type RealityProps, SSRProvider, SceneGraph, type SpatialContentReadyCallback, type SpatialContentReadyContext, type SpatialDragEndEntityEvent, type SpatialDragEndEvent, type SpatialDragEntityEvent, type SpatialDragEvent, type SpatialDragStartEntityEvent, type SpatialDragStartEvent, type SpatialEventOptions, type SpatialMagnifyEndEntityEvent, type SpatialMagnifyEndEvent, type SpatialMagnifyEntityEvent, type SpatialMagnifyEvent, SpatialMonitor, type SpatialRotateEndEntityEvent, type SpatialRotateEndEvent, type SpatialRotateEntityEvent, type SpatialRotateEvent, type SpatialTapEntityEvent, type SpatialTapEvent, Spatialized2DElementContainer, type Spatialized2DElementContainerProps, SpatializedContainer, type SpatializedElementRef, type SpatializedStatic3DContainerProps, SpatializedStatic3DElementContainer, type SpatializedStatic3DElementRef, SphereEntity as Sphere, SphereEntity, Texture, type TextureProps, UnlitMaterial, type UnlitMaterialProps, WebSpatialRuntime, SceneGraph as World, convertCoordinate, createElement, enableDebugTool, eventMap, getAbsoluteUrl, initPolyfill, initScene, useMetrics, version, withSpatialMonitor, withSpatialized2DElementContainer };